# Exemplo de skill gerada automaticamente pelo Memento-Skills
# skill: deploy_nodejs_ecs.py

"""
Skill: Deploy Node.js Application to AWS ECS
Gerada em: 2026-04-10T14:32:00Z
Executada com sucesso: 7 vezes
Última modificação: 2026-04-12 (adicionado rollback automático)
Confiança: 0.94
"""

from typing import Optional
import boto3

def deploy_nodejs_ecs(
    app_name: str,
    image_tag: str,
    cluster: str,
    service: str,
    region: str = "us-east-1",
    rollback_on_failure: bool = True
) -> dict:
    """
    Deploy de aplicação Node.js no ECS com rollback automático em caso de falha.
    Skill desenvolvida e refinada através de 7 execuções bem-sucedidas.
    """
    ecs = boto3.client("ecs", region_name=region)

    # Obtém task definition atual (para rollback)
    current_service = ecs.describe_services(
        cluster=cluster, services=[service]
    )["services"][0]
    previous_task_def = current_service["taskDefinition"]

    try:
        # Atualiza a task definition com a nova imagem
        task_def = ecs.describe_task_definition(
            taskDefinition=current_service["taskDefinition"]
        )["taskDefinition"]

        # Atualiza a imagem
        for container in task_def["containerDefinitions"]:
            if app_name in container["name"]:
                container["image"] = f"{container['image'].rsplit(':', 1)[0]}:{image_tag}"

        # Registra nova task definition
        new_task_def = ecs.register_task_definition(**{
            k: v for k, v in task_def.items()
            if k in ["family", "containerDefinitions", "volumes", "networkMode",
                     "requiresCompatibilities", "cpu", "memory"]
        })

        # Atualiza o serviço
        ecs.update_service(
            cluster=cluster,
            service=service,
            taskDefinition=new_task_def["taskDefinition"]["taskDefinitionArn"],
            forceNewDeployment=True
        )

        return {"status": "success", "task_definition": new_task_def["taskDefinition"]["taskDefinitionArn"]}

    except Exception as e:
        if rollback_on_failure:
            ecs.update_service(
                cluster=cluster, service=service,
                taskDefinition=previous_task_def
            )
        raise RuntimeError(f"Deploy falhou, rollback para {previous_task_def}: {e}")

# Ciclo de evolução do Memento-Skills (simplificado)

class SkillEvolutionEngine:
    def __init__(self, skill_store, llm_client):
        self.store = skill_store
        self.llm = llm_client

    def post_execution_hook(self, skill_name: str, execution_trace: dict):
        """Chamado após cada execução de skill"""

        skill = self.store.get(skill_name)
        success = execution_trace["outcome"] == "success"

        if not success:
            # Analisa falha e propõe correção
            patch = self._generate_patch(skill, execution_trace)
            if patch["confidence"] > 0.8:
                self.store.update(skill_name, patch["code"], reason="bug_fix")
            return

        # Execução bem-sucedida — verifica oportunidades de melhoria
        improvement = self._identify_improvements(skill, execution_trace)

        if improvement["has_improvement"] and improvement["confidence"] > 0.85:
            # Propõe melhoria mas aguarda validação em N execuções
            self.store.queue_improvement(skill_name, improvement)

        # A cada 10 execuções bem-sucedidas, consolida melhorias na fila
        if skill["execution_count"] % 10 == 0:
            self.store.apply_queued_improvements(skill_name)

    def _generate_patch(self, skill: dict, trace: dict) -> dict:
        """Usa o LLM para gerar correção baseada na falha"""
        prompt = f"""
        A seguinte skill falhou na execução:

        SKILL CODE:
        {skill['code']}

        ERRO:
        {trace['error']}

        TRACE DE EXECUÇÃO:
        {trace['steps']}

        Analise o erro e gere um patch para corrigir o problema.
        Responda em JSON: {{"code": "<código corrigido>", "confidence": <0-1>, "explanation": "<explicação>"}}
        """
        return self.llm.generate_json(prompt)

# RAG sobre skills — o agente "lembra" o que aprendeu
class SkillRetriever:
    def __init__(self, vector_store):
        self.vs = vector_store

    def get_relevant_skills(self, task_description: str, top_k: int = 5) -> list:
        """Busca skills semanticamente similares à tarefa atual"""
        skills = self.vs.similarity_search(task_description, k=top_k)

        # Filtra por confiança mínima (não retorna skills com baixo sucesso histórico)
        return [s for s in skills if s.metadata["confidence"] > 0.7]

    def format_for_context(self, skills: list) -> str:
        """Formata skills encontradas para incluir no contexto do agente"""
        if not skills:
            return ""

        formatted = "# Skills Disponíveis\n\nSkills aprendidas de execuções anteriores:\n\n"
        for skill in skills:
            formatted += f"""
## {skill.metadata['name']}
Confiança: {skill.metadata['confidence']:.0%} | Execuções: {skill.metadata['execution_count']}
Última modificação: {skill.metadata['last_modified']}

```python
{skill.page_content}

---

## A Conexão com SDD

O que o Memento-Skills está fazendo na camada de execução é, na essência, um ciclo de SDD (Spec-Driven Development) automatizado.

Em SDD, você define uma spec (o que o sistema deve fazer), implementa (como vai fazer), e valida (a implementação satisfaz a spec?). Quando não satisfaz, você itera.

O Memento-Skills faz exatamente isso para skills:
1. **Spec implícita**: o objetivo da tarefa define o que a skill deve fazer
2. **Implementação**: a skill em código
3. **Validação**: execução bem-sucedida ou falha
4. **Iteração**: o evolution engine modifica a skill baseado no resultado

A diferença é que o loop acontece automaticamente, sem intervenção humana entre iterações.

Isso tem implicações interessantes para times que já adotam SDD: o Memento-Skills pode ser visto como uma extensão do processo de spec para a camada de agentes. As specs que você escreve para seu sistema guiam o que os agentes tentam fazer; o Memento-Skills garante que eles ficam cada vez mais eficientes em executar isso.

<AdBanner />

---

## Os Riscos Reais de Agentes que se Auto-Modificam

Antes de sair implementando Memento-Skills em produção, é necessário falar sobre os riscos — que são reais e não triviais.

### Deriva Comportamental

Uma skill que começa resolvendo o problema A corretamente pode, após várias evoluções, resolver um problema ligeiramente diferente do A. Sem supervisão, o drift comportamental pode ser difícil de detectar até que cause um incidente.

```python
# Skill original: faz backup de arquivos modificados
# Após 15 evoluções "melhorando eficiência"...
# Skill evoluída (problema): agora deleta arquivos originais após backup
# "otimização" de espaço em disco que não estava no objetivo original

# Implementação conservadora com aprovação humana para mudanças críticas
class SafeSkillEvolutionEngine(SkillEvolutionEngine):
    CRITICAL_SKILLS = ["deploy_*", "delete_*", "payment_*", "auth_*"]
    AUTO_APPROVE_THRESHOLD = 0.95  # apenas patches com confiança muito alta

    def post_execution_hook(self, skill_name: str, execution_trace: dict):
        patch = super()._calculate_patch(skill_name, execution_trace)

        if not patch:
            return

        # Skills críticas sempre precisam de aprovação humana
        if any(pattern.replace("*", "") in skill_name for pattern in self.CRITICAL_SKILLS):
            self._queue_for_human_review(skill_name, patch)
            return

        # Patches com alta confiança em skills não-críticas podem ser auto-aplicados
        if patch["confidence"] >= self.AUTO_APPROVE_THRESHOLD:
            self.store.update(skill_name, patch["code"])
        else:
            self._queue_for_human_review(skill_name, patch)

    def _queue_for_human_review(self, skill_name: str, patch: dict):
        """Notifica equipe para revisar mudança proposta"""
        # Integra com seu sistema de review (GitHub PR, Jira, Slack, etc.)
        notification = {
            "type": "skill_evolution_review",
            "skill": skill_name,
            "proposed_change": patch,
            "priority": "high" if skill_name in self.CRITICAL_SKILLS else "normal"
        }
        self.notification_service.send(notification)