wegho-agentes 7.0.0 → 7.0.1

package/.agents/utils/agent-migrator.ts

@@ -1,360 +0,0 @@
-/**
- * Agent Migrator - Script para migrar agentes para nova estrutura
- * 
- * Este script cria a estrutura completa para cada agente:
- * - Pasta .agents/agents/[nome]/
- * - Copia agent.ts
- * - Cria README.md
- * - Copia specialty.md
- * - memory.md será criado pelo memory-converter
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-
-interface AgentInfo {
-    name: string;           // frontend, security, etc
-    className: string;      // FrontEndAgent, SecurityAgent, etc  
-    sourcePath: string;     // .agents/core/frontend-agent.ts
-    displayName: string;    // Front-End Agent
-    responsibility: string; // Responsabilidade principal
-}
-
-const AGENTS: AgentInfo[] = [
-    // Agentes Core
-    {
-        name: 'ai-agents',
-        className: 'AIAgentsAgent',
-        sourcePath: '.agents/core/ai-agents-agent.ts',
-        displayName: 'AI Agents Agent',
-        responsibility: 'Gerenciar e orquestrar outros agentes de IA'
-    },
-    {
-        name: 'architecture',
-        className: 'ArchitectureAgent',
-        sourcePath: '.agents/core/architecture-agent.ts',
-        displayName: 'Architecture Agent',
-        responsibility: 'Garantir arquitetura limpa, separação de camadas e organização'
-    },
-    {
-        name: 'automation',
-        className: 'AutomationAgent',
-        sourcePath: '.agents/core/automation-agent.ts',
-        displayName: 'Automation Agent',
-        responsibility: 'Automatizar tarefas repetitivas e workflows'
-    },
-    {
-        name: 'backend',
-        className: 'BackendAgent',
-        sourcePath: '.agents/core/backend-agent.ts',
-        displayName: 'Backend Agent',
-        responsibility: 'Validar APIs, lógica de negócio e integração com banco de dados'
-    },
-    {
-        name: 'cloud',
-        className: 'CloudAgent',
-        sourcePath: '.agents/core/cloud-agent.ts',
-        displayName: 'Cloud Agent',
-        responsibility: 'Gerenciar deploy, infraestrutura e serviços cloud'
-    },
-    {
-        name: 'cro',
-        className: 'CROAgent',
-        sourcePath: '.agents/core/cro-agent.ts',
-        displayName: 'CRO Agent',
-        responsibility: 'Otimizar taxa de conversão e experiência do usuário'
-    },
-    {
-        name: 'database',
-        className: 'DatabaseAgent',
-        sourcePath: '.agents/core/database-agent.ts',
-        displayName: 'Database Agent',
-        responsibility: 'Validar queries, índices, RLS policies e segurança de banco'
-    },
-    {
-        name: 'devops',
-        className: 'DevOpsAgent',
-        sourcePath: '.agents/core/devops-agent.ts',
-        displayName: 'DevOps Agent',
-        responsibility: 'CI/CD, containers, monitoramento e automação de deploy'
-    },
-    {
-        name: 'documentation',
-        className: 'DocumentationAgent',
-        sourcePath: '.agents/core/documentation-agent.ts',
-        displayName: 'Documentation Agent',
-        responsibility: 'Gerar e manter documentação automática do projeto'
-    },
-    {
-        name: 'frontend',
-        className: 'FrontEndAgent',
-        sourcePath: '.agents/core/frontend-agent.ts',
-        displayName: 'Front-End Agent',
-        responsibility: 'Garantir qualidade de UI/UX, acessibilidade e performance'
-    },
-    {
-        name: 'inventory',
-        className: 'InventoryAgent',
-        sourcePath: '.agents/core/inventory-agent.ts',
-        displayName: 'Inventory Agent',
-        responsibility: 'Catalogar componentes, padrões e recursos do projeto'
-    },
-    {
-        name: 'nextjs',
-        className: 'NextJSAgent',
-        sourcePath: '.agents/core/nextjs-agent.ts',
-        displayName: 'Next.js Agent',
-        responsibility: 'Validar uso correto de Next.js (RSC, routing, performance)'
-    },
-    {
-        name: 'pentest',
-        className: 'PentestAgent',
-        sourcePath: '.agents/core/pentest-agent.ts',
-        displayName: 'Pentest Agent',
-        responsibility: 'Executar testes de penetração e vulnerabilidades'
-    },
-    {
-        name: 'planning',
-        className: 'PlanningAgent',
-        sourcePath: '.agents/core/planning-agent.ts',
-        displayName: 'Planning Agent',
-        responsibility: 'Criar planos de implementação e quebrar tarefas complexas'
-    },
-    {
-        name: 'quality',
-        className: 'QualityAgent',
-        sourcePath: '.agents/core/quality-agent.ts',
-        displayName: 'Quality Agent',
-        responsibility: 'Auditar código, executar lint, build e testes (GO/NO-GO)'
-    },
-    {
-        name: 'rag',
-        className: 'RAGAgent',
-        sourcePath: '.agents/core/rag-agent.ts',
-        displayName: 'RAG Agent',
-        responsibility: 'Retrieval-Augmented Generation para consulta de documentação'
-    },
-    {
-        name: 'security',
-        className: 'SecurityAgent',
-        sourcePath: '.agents/core/security-agent.ts',
-        displayName: 'Security Agent',
-        responsibility: 'Validar vulnerabilidades, XSS, CSRF, SQL injection, RLS'
-    },
-    {
-        name: 'testing',
-        className: 'TestingAgent',
-        sourcePath: '.agents/core/testing-agent.ts',
-        displayName: 'Testing Agent',
-        responsibility: 'Criar e executar testes unitários e de integração'
-    },
-    {
-        name: 'uiux',
-        className: 'UIUXAgent',
-        sourcePath: '.agents/core/uiux-agent.ts',
-        displayName: 'UI/UX Agent',
-        responsibility: 'Validar design system, responsividade e usabilidade'
-    },
-    // Agentes Raiz
-    {
-        name: 'code-auditor',
-        className: 'CodeAuditorAgent',
-        sourcePath: '.agents/code-auditor-agent.ts',
-        displayName: 'Code Auditor Agent',
-        responsibility: 'Auditar código fonte e gerar relatórios de qualidade'
-    },
-    {
-        name: 'project-discovery',
-        className: 'ProjectDiscoveryAgent',
-        sourcePath: '.agents/project-discovery-agent.ts',
-        displayName: 'Project Discovery Agent',
-        responsibility: 'Descobrir estrutura e dependências do projeto'
-    },
-    {
-        name: 'task-analyzer',
-        className: 'TaskAnalyzerAgent',
-        sourcePath: '.agents/task-analyzer-agent.ts',
-        displayName: 'Task Analyzer Agent',
-        responsibility: 'Analisar tarefas e recomendar melhores agentes'
-    },
-];
-
-class AgentMigrator {
-    static migrateAgent(agent: AgentInfo): void {
-        const agentDir = path.join('.agents', 'agents', agent.name);
-
-        // 1. Criar pasta do agente
-        if (!fs.existsSync(agentDir)) {
-            fs.mkdirSync(agentDir, { recursive: true });
-        }
-
-        // 2. Copiar arquivo do agente (renomear para agent.ts)
-        const sourcePath = agent.sourcePath;
-        const destPath = path.join(agentDir, 'agent.ts');
-
-        if (fs.existsSync(sourcePath)) {
-            // Atualizar imports no arquivo
-            let content = fs.readFileSync(sourcePath, 'utf-8');
-
-            // Atualizar imports de base-agent e outros
-            content = content.replace(
-                /from\s+['"]\.\/base-agent\.js['"]/g,
-                "from '../../base/base-agent.js'"
-            );
-            content = content.replace(
-                /from\s+['"]\.\/memory-system\.js['"]/g,
-                "from '../../base/memory-system.js'"
-            );
-            content = content.replace(
-                /from\s+['"]\.\/skill-manager\.js['"]/g,
-                "from '../../base/skill-manager.js'"
-            );
-            content = content.replace(
-                /from\s+['"]\.\.\/config\.js['"]/g,
-                "from '../../config.js'"
-            );
-
-            fs.writeFileSync(destPath, content, 'utf-8');
-            console.log(`✅ ${agent.name}/agent.ts criado`);
-        } else {
-            console.warn(`⚠️  Arquivo fonte não encontrado: ${sourcePath}`);
-        }
-
-        // 3. Criar README.md
-        const readmePath = path.join(agentDir, 'README.md');
-        const readmeContent = this.generateReadme(agent);
-        fs.writeFileSync(readmePath, readmeContent, 'utf-8');
-        console.log(`✅ ${agent.name}/README.md criado`);
-
-        // 4. Copiar ou criar specialty.md
-        const oldSpecialtyPath = path.join('.agents', 'memory', `${agent.name}-agent`, 'specialty.md');
-        const newSpecialtyPath = path.join(agentDir, 'specialty.md');
-
-        if (fs.existsSync(oldSpecialtyPath)) {
-            fs.copyFileSync(oldSpecialtyPath, newSpecialtyPath);
-            console.log(`✅ ${agent.name}/specialty.md copiado`);
-        } else {
-            const defaultSpecialty = this.generateDefaultSpecialty(agent);
-            fs.writeFileSync(newSpecialtyPath, defaultSpecialty, 'utf-8');
-            console.log(`✅ ${agent.name}/specialty.md criado (padrão)`);
-        }
-
-        console.log(`✅ ${agent.displayName} migrado com sucesso!\n`);
-    }
-
-    static generateReadme(agent: AgentInfo): string {
-        return `# ${agent.displayName}
-
-## 🎯 Responsabilidade
-
-${agent.responsibility}
-
-## 🛠️ Skills
-
-### Skill 1: Validação de Código
-**Propósito**: Analisar código e identificar problemas  
-**Quando usar**: Antes de commits, PRs e deploys  
-**Exemplo**:
-\`\`\`typescript
-const result = await agent.executeTask(
-    "Validar componente",
-    { files: ["component.tsx"], areas: ["frontend"], complexity: "medium" }
-);
-\`\`\`
-
-### Skill 2: Aprendizado Contínuo
-**Propósito**: Aprender com sucessos e falhas para melhorar recomendações  
-**Quando usar**: Após cada tarefa executada  
-**Exemplo**:
-\`\`\`typescript
-await agent.learn(
-    "Components > 500 lines",
-    "Componente muito grande",
-    "Dividir em sub-componentes",
-    ["task-123", "task-456"]
-);
-\`\`\`
-
-### Skill 3: Consulta de Memória
-**Propósito**: Buscar casos similares e recomendações baseadas no histórico  
-**Quando usar**: Antes de iniciar novas tarefas  
-
-## 📋 Tarefas Típicas
-
-- Validar arquivos do projeto
-- Gerar relatórios de qualidade
-- Aplicar padrões e best practices
-- Aprender com feedback do usuário
-
-## 🔗 Dependências
-
-- \`BaseAgent\` (classe pai)
-- \`MemorySystem\` (persistência)
-- \`SkillManager\` (gerenciamento de skills)
-
-## 📊 Memória
-
-A memória deste agente é persistida em \`memory.md\` com histórico de:
-- ✅ Sucessos
-- ❌ Falhas  
-- 🧠 Aprendizados
-
-Para consultar a memória:
-\`\`\`typescript
-const stats = agent.getStats();
-console.log(\`Taxa de sucesso: \${stats.successRate}%\`);
-\`\`\`
-
-## 📝 Specialty
-
-Veja \`specialty.md\` para detalhes sobre expertise, regras e responsabilidades específicas.
-`;
-    }
-
-    static generateDefaultSpecialty(agent: AgentInfo): string {
-        return `# ${agent.displayName} - Especialidade
-
-## Responsabilidades
-- ${agent.responsibility}
-- Aprender com casos de sucesso e falha
-- Aplicar melhores práticas
-
-## Expertise
-- Análise de código
-- Validação de padrões
-- Geração de relatórios
-
-## Regras
-- Arquivos < 500 linhas
-- Não alucinar APIs ou bibliotecas
-- Priorizar libs existentes
-- Fonte de verdade: código → docs → padrões
-
-## Tarefas Típicas
-- Validar implementações
-- Gerar recomendações
-- Aplicar aprendizados anteriores
-`;
-    }
-
-    static migrateAll(): void {
-        console.log(`\n🚀 Iniciando migração de ${AGENTS.length} agentes...\n`);
-
-        AGENTS.forEach(agent => {
-            try {
-                this.migrateAgent(agent);
-            } catch (error: any) {
-                console.error(`❌ Erro ao migrar ${agent.name}:`, error.message);
-            }
-        });
-
-        console.log(`\n✅ Migração concluída! ${AGENTS.length} agentes processados.`);
-    }
-}
-
-// CLI
-if (require.main === module) {
-    AgentMigrator.migrateAll();
-}
-
-export { AgentMigrator, AGENTS };

package/.agents/utils/agent-monitor.ts

@@ -1,102 +0,0 @@
-/**
- * Agent Monitor - Rastreia agentes ativos em tempo real
- */
-
-export interface ActiveAgent {
-    name: string;
-    status: 'starting' | 'running' | 'waiting' | 'completed' | 'failed';
-    startedAt: Date;
-    task: string;
-}
-
-export class AgentMonitor {
-    private activeAgents: Map<string, ActiveAgent> = new Map();
-
-    /**
-     * Registra início de execução de um agente
-     */
-    trackAgentStart(agentName: string, task: string): void {
-        this.activeAgents.set(agentName, {
-            name: agentName,
-            status: 'starting',
-            startedAt: new Date(),
-            task
-        });
-    }
-
-    /**
-     * Atualiza status de um agente
-     */
-    updateAgentStatus(agentName: string, status: ActiveAgent['status']): void {
-        const agent = this.activeAgents.get(agentName);
-        if (agent) {
-            agent.status = status;
-        }
-    }
-
-    /**
-     * Remove agente do tracking (completou ou falhou)
-     */
-    trackAgentEnd(agentName: string): void {
-        this.activeAgents.delete(agentName);
-    }
-
-    /**
-     * Gera relatório visual de agentes ativos
-     */
-    reportActiveAgents(): string {
-        if (this.activeAgents.size === 0) {
-            return '🤖 Nenhum agente ativo no momento.';
-        }
-
-        let report = '🤖 AGENTES ATIVOS:\\n';
-
-        for (const agent of this.activeAgents.values()) {
-            const emoji = this.getStatusEmoji(agent.status);
-            const duration = this.getElapsedTime(agent.startedAt);
-            report += `  ${emoji} ${agent.name} - ${agent.task} (${duration})\\n`;
-        }
-
-        return report;
-    }
-
-    /**
-     * Retorna emoji baseado no status
-     */
-    private getStatusEmoji(status: ActiveAgent['status']): string {
-        const emojiMap = {
-            'starting': '🔄',
-            'running': '✅',
-            'waiting': '⏸️',
-            'completed': '✔️',
-            'failed': '❌'
-        };
-        return emojiMap[status];
-    }
-
-    /**
-     * Calcula tempo decorrido
-     */
-    private getElapsedTime(startedAt: Date): string {
-        const elapsed = Date.now() - startedAt.getTime();
-        const seconds = Math.floor(elapsed / 1000);
-
-        if (seconds < 60) {
-            return `${seconds}s`;
-        }
-
-        const minutes = Math.floor(seconds / 60);
-        const remainingSeconds = seconds % 60;
-        return `${minutes}m ${remainingSeconds}s`;
-    }
-
-    /**
-     * Retorna lista de agentes ativos (para uso programático)
-     */
-    getActiveAgents(): ActiveAgent[] {
-        return Array.from(this.activeAgents.values());
-    }
-}
-
-// Singleton global para compartilhar entre agentes
-export const globalAgentMonitor = new AgentMonitor();

package/.agents/utils/agent-parallelizer.ts

@@ -1,108 +0,0 @@
-/**
- * Agent Parallelization Utility
- * 
- * Identifica agentes independentes e os executa em paralelo
- * para reduzir tempo total de execução
- */
-
-import { AgentAssignment } from '../task-analyzer-agent.js';
-
-export interface AgentGroup {
-    parallel: AgentAssignment[];
-    sequential: AgentAssignment[];
-}
-
-export class AgentParallelizer {
-    /**
-     * Mapa de dependências entre agentes
-     * Agentes que dependem de outros devem executar depois
-     */
-    private static readonly DEPENDENCIES: Record<string, string[]> = {
-        // Architecture deve rodar antes de outros agentes técnicos
-        'frontend-agent': ['architecture-agent'],
-        'security-agent': [],  // Independente
-        'quality-agent': ['frontend-agent', 'architecture-agent'],
-        'documentation-agent': [], // Pode rodar em paralelo
-
-        // Agentes de domínio geralmente independentes
-        'cms-agent': [],
-        'seo-agent': [],
-        'production-control-agent': [],
-        'route-agent': [],
-
-        // Inventory deve rodar primeiro (coleta informações)
-        'pentesting-agent': ['security-agent']
-    };
-
-    /**
-     * Agrupa agentes em grupos paralelos e sequenciais
-     */
-    static groupAgents(agents: AgentAssignment[]): AgentAssignment[][] {
-        const groups: AgentAssignment[][] = [];
-        const processed = new Set<string>();
-        const remaining = [...agents].sort((a, b) => a.priority - b.priority);
-
-        while (remaining.length > 0) {
-            const currentGroup: AgentAssignment[] = [];
-
-            // Encontrar agentes que podem executar em paralelo
-            for (let i = remaining.length - 1; i >= 0; i--) {
-                const agent = remaining[i];
-                const dependencies = this.DEPENDENCIES[agent.agentName] || [];
-
-                // Verificar se todas as dependências já foram processadas
-                const canRun = dependencies.every(dep => processed.has(dep));
-
-                if (canRun) {
-                    currentGroup.push(agent);
-                    remaining.splice(i, 1);
-                }
-            }
-
-            if (currentGroup.length === 0) {
-                // Deadlock - alguma dependência circular ou não resolvida
-                // Executar o próximo agente sequencialmente
-                currentGroup.push(remaining.shift()!);
-            }
-
-            // Marcar agentes como processados
-            currentGroup.forEach(agent => processed.add(agent.agentName));
-            groups.push(currentGroup);
-        }
-
-        return groups;
-    }
-
-    /**
-     * Verifica se dois agentes podem executar em paralelo
-     */
-    static canRunInParallel(agent1: string, agent2: string): boolean {
-        const deps1 = this.DEPENDENCIES[agent1] || [];
-        const deps2 = this.DEPENDENCIES[agent2] || [];
-
-        // Não podem rodar em paralelo se um depende do outro
-        return !deps1.includes(agent2) && !deps2.includes(agent1);
-    }
-
-    /**
-     * Estima redução de tempo com paralelização
-     */
-    static estimateTimeReduction(agents: AgentAssignment[]): {
-        sequential: number;
-        parallel: number;
-        reduction: number;
-    } {
-        const groups = this.groupAgents(agents);
-        const avgTimePerAgent = 10; // segundos (estimativa)
-
-        const sequentialTime = agents.length * avgTimePerAgent;
-        const parallelTime = groups.length * avgTimePerAgent;
-        const reduction = ((sequentialTime - parallelTime) / sequentialTime) * 100;
-
-        return {
-            sequential: sequentialTime,
-            parallel: parallelTime,
-            reduction: Math.round(reduction)
-        };
-    }
-}