Create yp.s resopmocC

aduc_framework/engineers/yp.s resopmocC

@@ -0,0 +1,200 @@
+# aduc_framework/engineers/composer.py
+#
+# Copyright (C) August 4, 2025  Carlos Rodrigues dos Santos
+#
+# Versão 2.0.0 (Agnostic & Conversational Execution Engine)
+#
+# O Composer é o Mestre de Obras. Ele executa um plano de pré-produção,
+# construindo o DNA Bruto através de uma conversa com o LLM, orquestrada
+# de forma agnóstica ao modelo através do PromptEngine.
+
+import logging
+import json
+import re
+from pathlib import Path
+from PIL import Image
+from typing import List, Dict, Any, Generator, Optional, Callable
+
+# Importa os componentes com os quais ele interage
+from .prompt_engine import prompt_engine_singleton
+from ..managers.llama_multimodal_manager import llama_multimodal_manager_singleton
+
+logger = logging.getLogger(__name__)
+
+def robust_json_parser(raw_text: str) -> dict:
+    """
+    Tenta extrair e parsear um objeto JSON de uma string que pode conter
+    texto adicional, explicações ou blocos de código markdown.
+    """
+    logger.debug(f"Tentando parsear JSON do texto bruto (primeiros 500 chars):\n---\n{raw_text[:500]}\n---")
+    # Padrão para extrair de um bloco de código ```json ... ```
+    match = re.search(r'```json\s*(\{.*?\})\s*```', raw_text, re.DOTALL)
+    if match:
+        json_str = match.group(1)
+        logger.debug("Bloco de código JSON explícito encontrado, parseando...")
+        return json.loads(json_str)
+
+    # Se não, tenta encontrar o primeiro '{' e o último '}' no texto
+    try:
+        start_index = raw_text.find('{')
+        end_index = raw_text.rfind('}')
+        if start_index != -1 and end_index != -1 and end_index > start_index:
+            json_str = raw_text[start_index : end_index + 1]
+            logger.debug("JSON encontrado por delimitadores '{...}', parseando...")
+            return json.loads(json_str)
+    except json.JSONDecodeError:
+        pass  # Ignora e tenta a abordagem final
+
+    # Como último recurso, tenta parsear o texto inteiro
+    logger.debug("Nenhum delimitador ou bloco de código encontrado, tentando parsear o texto inteiro...")
+    return json.loads(raw_text)
+
+class Composer:
+    """
+    O Composer executa um plano de trabalho, supervisionando o LLM para
+    realizar cada tarefa e construir o DNA de pré-produção de forma iterativa.
+    """
+
+    def __init__(self):
+        """
+        Inicializa o Composer carregando os templates de tarefa genéricos.
+        """
+        self.task_templates = self._load_task_templates()
+        logger.info(f"Composer inicializado com {len(self.task_templates)} templates de tarefa.")
+
+    def _load_task_templates(self) -> Dict[str, str]:
+        """Carrega todos os templates de tarefa genéricos da pasta 'task_templates'."""
+        templates = {}
+        template_dir = Path(__file__).resolve().parent.parent / "prompts" / "task_templates"
+        if not template_dir.is_dir():
+            raise FileNotFoundError(f"Diretório de templates de tarefa não encontrado: {template_dir}")
+
+        for task_file in template_dir.glob("*.txt"):
+            task_id = task_file.stem
+            with open(task_file, 'r', encoding='utf-8') as f:
+                templates[task_id] = f.read()
+        return templates
+
+    def _talk_to_llama(self, generic_prompt: str, images: Optional[List[Image.Image]] = None, expected_format="text") -> Any:
+        """
+        Wrapper completo para o ciclo de comunicação: Tradução + Execução.
+        """
+        # 1. Traduz o prompt genérico para o formato específico do modelo
+        final_model_prompt = prompt_engine_singleton.translate(generic_prompt)
+
+        # 2. Loga a entrada para a UI
+        log_entry_request = {
+            "direction": "to_llama", "prompt": final_model_prompt,
+            "image_count": len(images) if images else 0, "expected_format": expected_format
+        }
+        logger.info(f"==> ENVIANDO TAREFA PARA O LLAMA (Esperando {expected_format}):\n{final_model_prompt[:400]}...")
+        
+        # 3. Executa a chamada ao LLM
+        response_raw = llama_multimodal_manager_singleton.process_turn(
+            prompt_text=final_model_prompt, image_list=images
+        )
+
+        # 4. Loga a saída para a UI
+        log_entry_response = {"direction": "from_llama", "raw_response": response_raw}
+        logger.info(f"<== RESPOSTA BRUTA RECEBIDA DO LLAMA:\n{response_raw[:400]}...")
+
+        # 5. Processa a saída
+        if expected_format == "json":
+            try:
+                parsed_json = robust_json_parser(response_raw)
+                return parsed_json
+            except (json.JSONDecodeError, ValueError) as e:
+                logger.error(f"Falha ao parsear JSON da resposta do LLAMA. Resposta bruta: {response_raw}", exc_info=True)
+                raise ValueError(f"O LLM retornou um formato JSON inválido. Erro: {e}")
+        return response_raw
+
+    def execute_plan(
+        self,
+        execution_plan: List[Dict[str, Any]],
+        initial_data: Dict[str, Any],
+        callback: Optional[Callable] = None
+    ) -> Generator[Dict[str, Any], None, Dict[str, Any]]:
+        """
+        Executa um plano de trabalho tarefa por tarefa, emitindo atualizações
+        de progresso e construindo o DNA.
+        """
+        llama_multimodal_manager_singleton.reset_chat()
+        
+        dna = {
+            "global_prompt": initial_data["global_prompt"],
+            "initial_media_paths": initial_data["user_media_paths"],
+            "asset_catalog": {}, "story_summary": "", "scenes": []
+        }
+        user_media = [Image.open(p) for p in initial_data["user_media_paths"]]
+        total_tasks = len(execution_plan)
+
+        for i, task in enumerate(execution_plan):
+            task_id = task['task_id']
+            progress_fraction = (i + 0.1) / total_tasks
+            message = f"({i+1}/{total_tasks}) {task['description']}"
+            if callback: callback(progress_fraction, desc=message)
+            yield {"status": "progress", "progress": progress_fraction, "message": message, "dna_snapshot": dna}
+            
+            generic_template = self.task_templates.get(task_id)
+            if not generic_template:
+                logger.warning(f"Nenhum template encontrado para a tarefa '{task_id}'. Pulando.")
+                continue
+
+            # Prepara os dados para o template, incluindo o estado atual do DNA
+            template_data = {**task['inputs'], **dna}
+            
+            # --- Lógica de Execução de Tarefas Específicas ---
+            if task_id == "PREPROD_01_CATALOG_ASSETS":
+                prompt = generic_template.format(**template_data)
+                # A primeira tarefa envia todas as mídias do usuário
+                asset_catalog = self._talk_to_llama(prompt, user_media, "json")
+                dna["asset_catalog"] = asset_catalog
+
+            elif task_id == "PREPROD_02_SCORE_ASSETS":
+                prompt = generic_template.format(asset_catalog_str=json.dumps(dna["asset_catalog"], indent=2), **template_data)
+                scored_catalog = self._talk_to_llama(prompt, expected_format="json")
+                dna["asset_catalog"] = scored_catalog
+            
+            elif task_id == "PREPROD_03_CREATE_SUMMARY":
+                prompt = generic_template.format(**template_data)
+                summary = self._talk_to_llama(prompt, expected_format="text")
+                dna["story_summary"] = summary
+            
+            elif task_id == "PREPROD_04_FRAGMENT_SCENES":
+                prompt = generic_template.format(
+                    asset_catalog_str=json.dumps(dna["asset_catalog"], indent=2),
+                    **template_data
+                )
+                scenes_data = self._talk_to_llama(prompt, expected_format="json")
+                dna["scenes"] = scenes_data.get("scenes", [])
+
+            elif task_id == "PREPROD_05_REVIEW_PLAN":
+                 prompt = generic_template.format(scenes_str=json.dumps(dna["scenes"], indent=2))
+                 review = self._talk_to_llama(prompt, expected_format="json")
+                 if review.get("changes_needed", False):
+                     dna["scenes"] = review.get("updated_scenes", dna["scenes"])
+                     logger.info("Plano de cenas foi ajustado pelo LLM após revisão.")
+                 else:
+                     logger.info("LLM confirmou a coerência do plano de cenas.")
+
+            elif task_id == "PREPROD_06_FRAGMENT_ACTS":
+                prompt = generic_template.format(
+                    scenes_str=json.dumps(dna["scenes"], indent=2),
+                    **template_data
+                )
+                final_plan = self._talk_to_llama(prompt, expected_format="json")
+                dna["scenes"] = final_plan.get("scenes_with_acts", [])
+
+            task['status'] = 'complete'
+            progress_fraction = (i + 1) / total_tasks
+            if callback: callback(progress_fraction, desc=f"({i+1}/{total_tasks}) Tarefa Concluída!")
+            yield {"status": "progress", "progress": progress_fraction, "message": f"Tarefa '{task_id}' concluída.", "dna_snapshot": dna}
+
+        final_message = "Plano de pré-produção concluído com sucesso."
+        logger.info(final_message)
+        yield {"status": "complete", "progress": 1.0, "message": final_message, "dna": dna}
+        return dna
+
+# --- Instância Singleton ---
+# A seleção do mapa de modelo é feita no PromptEngine, tornando o Composer agnóstico.
+composer_singleton = Composer()