wegho-agentes 7.0.0 → 7.0.1

package/.agent/skills/wegho-global-rules/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: wegho-global-rules
+description: Always-on rules for wegho-agentes. Applies to any task in this workspace and must be loaded on every agent switch.
+---
+
+# Wegho Global Rules
+
+This skill enforces the global rules and mandatory workflow for all agents.
+
+## Always load these files before doing any work
+- `docs/AGENT_RULES.md`
+- `.agents/AGENT_WORKFLOW.md`
+- `.agent/workflows/run-agents-workflow.md`
+
+## Mandatory behavior
+1. Follow all rules in `docs/AGENT_RULES.md` with no exceptions.
+2. Execute the mandatory workflow steps from `.agents/AGENT_WORKFLOW.md` for every task.
+3. If you switch agents or if more than 10 minutes pass, re-read the files above and restate the constraints before continuing.
+4. If any rule conflicts with the user request, stop and ask for clarification.
+5. If a workflow step cannot be completed, report it explicitly and block completion.

package/.agent/workflows/PROMPT_GUIDE.md

@@ -1,9 +1,12 @@
 # Prompt Completo para Executar Workflow dos Agentes
 
-## 🎯 Objetivo
-Executar o sistema de agentes `wegho-agentes` garantindo que todos os 6 passos obrigatórios sejam seguidos e validados.
-
----
+## 🎯 Objetivo
+Executar o sistema de agentes `wegho-agentes` garantindo que todos os 6 passos obrigatórios sejam seguidos e validados.
+
+## ✅ Regra global (Antigravity)
+Sempre carregar a skill `wegho-global-rules` antes de executar qualquer tarefa ou trocar de agente.
+
+---
 
 ## 📋 Prompt para IA
 

package/.agents/cli.ts

@@ -16,11 +16,17 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
 import * as readline from 'readline';
-import { IntelligentOrchestrator } from './orchestrator.js';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { IntelligentOrchestrator } from './orchestrator.js';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function estimateTokens(text: string): number {
+    const normalized = text.trim();
+    if (!normalized) return 0;
+    return Math.ceil(normalized.length / 4);
+}
 
 // Define commands using a mapped type or interface if needed, but simple object is fine
 const COMMANDS: Record<string, () => Promise<void> | void> = {
@@ -401,22 +407,24 @@ async function main(): Promise<void> {
     // Se não for um comando explícito (!), trate como uma tarefa para o orquestrador
     const isCommand = command.startsWith('!');
 
-    if (isCommand) {
-        const handler = COMMANDS[command.toLowerCase()];
-        if (!handler) {
-            console.log(`\n❌ Comando não encontrado: ${command}\n`);
-            console.log('💡 Use "!comandos" para ver a lista completa.\n');
-            process.exit(1);
-        }
-        await handler();
-    } else {
-        // Modo Tarefa: "npm run agent 'Minha tarefa'"
-        try {
-            const taskDescription = process.argv.slice(2).join(' ');
-            console.log(`\n🤖 Nova tarefa recebida: "${taskDescription}"\n`);
-
-            const context = await initializeContext(true);
-            const orchestrator = new IntelligentOrchestrator(context);
+    if (isCommand) {
+        console.log(`🧮 Tokens estimados (comando): ${estimateTokens(command)}`);
+        const handler = COMMANDS[command.toLowerCase()];
+        if (!handler) {
+            console.log(`\n❌ Comando não encontrado: ${command}\n`);
+            console.log('💡 Use "!comandos" para ver a lista completa.\n');
+            process.exit(1);
+        }
+        await handler();
+    } else {
+        // Modo Tarefa: "npm run agent 'Minha tarefa'"
+        try {
+            const taskDescription = process.argv.slice(2).join(' ');
+            console.log(`\n🤖 Nova tarefa recebida: "${taskDescription}"\n`);
+            console.log(`🧮 Tokens estimados (tarefa): ${estimateTokens(taskDescription)}\n`);
+
+            const context = await initializeContext(true);
+            const orchestrator = new IntelligentOrchestrator(context);
 
             await orchestrator.orchestrateTask(taskDescription);
         } catch (error: any) {

package/.agents/core/base-agent.ts

@@ -65,16 +65,19 @@ export abstract class BaseAgent {
     /**
      * Executa tarefa consultando memória
      */
-    async executeWithMemory(taskDescription: string, context: TaskContext): Promise<TaskResult> {
-        console.log(`\n${'='.repeat(60)}`);
-        console.log(`🤖 AGENTE ATIVO: ${this.agentName.toUpperCase()}`);
-        console.log(`${'='.repeat(60)}`);
-        console.log(`📋 Tarefa: ${taskDescription}`);
-        console.log(`⏰ Início: ${new Date().toLocaleTimeString('pt-BR')}\n`);
-
-        // PASSO 1: Consultar casos similares
-        this.markStepCompleted('Consultar Memória', { count: 0 });
-        const similarCases = this.memory.getSimilarCases(this.agentName, taskDescription, 5);
+    async executeWithMemory(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        console.log(`\n${'='.repeat(60)}`);
+        console.log(`🤖 AGENTE ATIVO: ${this.agentName.toUpperCase()}`);
+        console.log(`${'='.repeat(60)}`);
+        console.log(`📋 Tarefa: ${taskDescription}`);
+        console.log(`⏰ Início: ${new Date().toLocaleTimeString('pt-BR')}\n`);
+
+        // Resetar passos do workflow a cada execução
+        this.initializeWorkflowSteps();
+
+        // PASSO 1: Consultar casos similares
+        this.markStepCompleted('Consultar Memória', { count: 0 });
+        const similarCases = this.memory.getSimilarCases(this.agentName, taskDescription, 5);
 
         if (similarCases.length > 0) {
             console.log(`💭 [${this.agentName}] Encontrei ${similarCases.length} caso(s) similar(es):`);
@@ -85,8 +88,21 @@ export abstract class BaseAgent {
                     console.log(`     Feedback: ${case_.userFeedback.satisfied ? '👍' : '👎'}`);
                 }
             });
-            this.updateStepDetails('Consultar Memória', { count: similarCases.length });
-        }
+            this.updateStepDetails('Consultar Memória', { count: similarCases.length });
+        }
+
+        // Verificar últimas mudanças relacionadas aos arquivos da tarefa
+        if (context.files && context.files.length > 0) {
+            const latestEntries = this.memory.getLatestEntriesForFiles(this.agentName, context.files, 3);
+            if (latestEntries.length > 0) {
+                console.log(`\n🕵️  [${this.agentName}] Últimas mudanças relacionadas aos arquivos da tarefa:`);
+                latestEntries.forEach((entry, index) => {
+                    const status = entry.result === 'success' ? '✅' : '❌';
+                    const when = new Date(entry.timestamp as any).toLocaleString('pt-BR');
+                    console.log(`  ${index + 1}. ${status} ${entry.taskDescription} (${when})`);
+                });
+            }
+        }
 
         // PASSO 2: Obter recomendações baseadas em aprendizados
         this.markStepCompleted('Obter Recomendações', { count: 0 });

package/.agents/core/memory-system.ts

@@ -68,7 +68,7 @@ export interface AgentMemory {
 /**
  * Sistema de Memória
  */
-export class MemorySystem {
+export class MemorySystem {
     private memoryBasePath: string;
     private maxEntries: number;
     private cache: CacheManager;
@@ -283,7 +283,7 @@ export class MemorySystem {
     /**
      * Obtém recomendações baseadas em aprendizados
      */
-    getRecommendations(agentName: string, taskDescription: string): string[] {
+    getRecommendations(agentName: string, taskDescription: string): string[] {
         // Verificar cache primeiro
         const cacheKey = `recommendations:${agentName}:${taskDescription}`;
         const cached = this.cache.get<string[]>(cacheKey);
@@ -308,8 +308,32 @@ export class MemorySystem {
         // Cachear resultado
         this.cache.set(cacheKey, results, 120000); // 2 minutos TTL
 
-        return results;
-    }
+        return results;
+    }
+
+    /**
+     * Retorna as últimas entradas relacionadas a arquivos/páginas
+     */
+    getLatestEntriesForFiles(
+        agentName: string,
+        files: string[],
+        limit: number = 3
+    ): MemoryEntry[] {
+        const normalizedFiles = files.map(f => this.normalizePath(f));
+        if (normalizedFiles.length === 0) return [];
+
+        const memory = this.loadMemory(agentName);
+        const allEntries = [...memory.successes, ...memory.failures];
+
+        const matches = allEntries.filter(entry => {
+            const entryFiles = (entry.context?.files || []).map(f => this.normalizePath(f));
+            return entryFiles.some(ef => normalizedFiles.some(nf => ef.includes(nf) || nf.includes(ef)));
+        });
+
+        return matches
+            .sort((a, b) => this.toDate(b.timestamp).getTime() - this.toDate(a.timestamp).getTime())
+            .slice(0, limit);
+    }
 
     /**
      * Obtém estatísticas do cache
@@ -386,12 +410,20 @@ export class MemorySystem {
             .filter(word => word.length > 3);
     }
 
-    private calculateSimilarity(keywords1: string[], keywords2: string[]): number {
-        const set1 = new Set(keywords1);
-        const set2 = new Set(keywords2);
-        const intersection = new Set([...set1].filter(k => set2.has(k)));
-        const union = new Set([...set1, ...set2]);
-
-        return union.size > 0 ? intersection.size / union.size : 0;
-    }
-}
+    private calculateSimilarity(keywords1: string[], keywords2: string[]): number {
+        const set1 = new Set(keywords1);
+        const set2 = new Set(keywords2);
+        const intersection = new Set([...set1].filter(k => set2.has(k)));
+        const union = new Set([...set1, ...set2]);
+
+        return union.size > 0 ? intersection.size / union.size : 0;
+    }
+
+    private normalizePath(input: string): string {
+        return input.trim().replace(/\\/g, '/').toLowerCase();
+    }
+
+    private toDate(value: Date | string): Date {
+        return value instanceof Date ? value : new Date(value);
+    }
+}

package/.agents/core/report-generator.ts

@@ -110,16 +110,20 @@ export class ReportGenerator {
         }
 
         // Como testar
-        if (report.status === 'success') {
-            markdown += `## 🧪 Como Testar\n\n`;
-            markdown += `\`\`\`bash\n`;
-            markdown += `npm run dev\n`;
-            markdown += `# Acesse http://localhost:3000\n`;
-            markdown += `\`\`\`\n\n`;
-        }
-
-        markdown += `---\n\n`;
-        markdown += `**Gerado em**: ${new Date().toLocaleString('pt-BR')}\n`;
+        if (report.status === 'success') {
+            markdown += `## 🧪 Como Testar\n\n`;
+            markdown += `\`\`\`bash\n`;
+            markdown += `npm run dev\n`;
+            markdown += `# Acesse http://localhost:3000\n`;
+            markdown += `\`\`\`\n\n`;
+        }
+
+        markdown += `## ✅ Confirmação\n\n`;
+        markdown += `Tem algo a modificar a mais ou posso mandar para o github?\n\n`;
+        markdown += `Por favor, faça um resumo do que foi feito para não perder a memória.\n\n`;
+
+        markdown += `---\n\n`;
+        markdown += `**Gerado em**: ${new Date().toLocaleString('pt-BR')}\n`;
 
         return markdown;
     }
@@ -182,12 +186,15 @@ export class ReportGenerator {
             console.log('');
         }
 
-        if (report.status === 'success' && report.nextSteps.length > 0) {
-            console.log('📚 Próximos passos:');
-            report.nextSteps.forEach((step, i) => console.log(`   ${i + 1}. ${step}`));
-            console.log('');
-        }
-
-        console.log('='.repeat(60) + '\n');
-    }
-}
+        if (report.status === 'success' && report.nextSteps.length > 0) {
+            console.log('📚 Próximos passos:');
+            report.nextSteps.forEach((step, i) => console.log(`   ${i + 1}. ${step}`));
+            console.log('');
+        }
+
+        console.log('❓ Tem algo a modificar a mais ou posso mandar para o github?');
+        console.log('📝 Por favor, faça um resumo do que foi feito para não perder a memória.\n');
+
+        console.log('='.repeat(60) + '\n');
+    }
+}

package/.agents/orchestrator.ts

@@ -9,14 +9,12 @@
  * - Dar decisão final GO/NO-GO
  */
 
-import { execSync } from 'child_process';
-
-import { FrontEndAgent } from './agents/frontend/agent.js';
-import { SecurityAgent } from './agents/security/agent.js';
-import { ArchitectureAgent } from './agents/architecture/agent.js';
-import { QualityAgent } from './agents/quality/agent.js';
-import { DocumentationAgent } from './agents/documentation/agent.js';
-import { InventoryAgent } from './agents/inventory/agent.js';
+import { FrontEndAgent } from './core/frontend-agent.js';
+import { SecurityAgent } from './core/security-agent.js';
+import { ArchitectureAgent } from './core/architecture-agent.js';
+import { QualityAgent } from './core/quality-agent.js';
+import { DocumentationAgent } from './core/documentation-agent.js';
+import { InventoryAgent } from './core/inventory-agent.js';
 
 // Domain Agents
 import { CMSAgent } from './domains/news/cms-agent.js';
@@ -24,33 +22,34 @@ import { SEOAgent } from './domains/news/seo-agent.js';
 import { ProductionControlAgent } from './domains/production/production-control-agent.js';
 import { RouteAgent } from './domains/logistics/route-agent.js';
 
-import { TaskAnalyzerAgent, TaskAnalysis, AgentAssignment } from './agents/task-analyzer/agent.js';
-import { MemorySystem } from './base/memory-system.js';
-import { FeedbackCollector, UserFeedback } from './utils/feedback-collector.js';
+import { TaskAnalyzerAgent, TaskAnalysis, AgentAssignment } from './task-analyzer-agent.js';
+import { MemorySystem } from './core/memory-system.js';
+import { FeedbackCollector, UserFeedback } from './core/feedback-collector.js';
 import { PythonBridge } from './security/python-bridge.js';
 import { AgentConfig, DEFAULT_CONFIG } from './config.js';
 import { ProjectContext } from './context-loader.js';
-import { BaseAgent, TaskContext, TaskResult } from './base/base-agent.js';
-import { RetryUtility } from './utils/retry-utility.js';
-import { AgentParallelizer } from './utils/agent-parallelizer.js';
-import { PerformanceTracker } from './utils/performance-tracker.js';
-import { PlanningAgent, ImplementationPlan } from './agents/planning/agent.js';
-import { CheckpointManager } from './managers/checkpoint-manager.js';
-import { FileGenerator } from './utils/file-generator.js';
-import { ReportGenerator, ExecutionReport } from './utils/report-generator.js';
-import { NextJSAgent } from './agents/nextjs/agent.js';
-import { UIUXAgent } from './agents/uiux/agent.js';
-import { BackendAgent } from './agents/backend/agent.js';
-import { DatabaseAgent } from './agents/database/agent.js';
-import { AIAgentsAgent } from './agents/ai-agents/agent.js';
-import { RAGAgent } from './agents/rag/agent.js';
-import { PentestAgent } from './agents/pentest/agent.js';
-import { DevOpsAgent } from './agents/devops/agent.js';
-import { CloudAgent } from './agents/cloud/agent.js';
-import { TestingAgent } from './agents/testing/agent.js';
-import { CROAgent } from './agents/cro/agent.js';
-import { AutomationAgent } from './agents/automation/agent.js';
-import { BuildManager } from './managers/build-manager.js';
+import { BaseAgent, TaskContext, TaskResult } from './core/base-agent.js';
+import { RetryUtility } from './core/retry-utility.js';
+import { AgentParallelizer } from './core/agent-parallelizer.js';
+import { PerformanceTracker } from './core/performance-tracker.js';
+import { WorkflowValidator } from './core/workflow-validator.js';
+import { PlanningAgent, ImplementationPlan } from './core/planning-agent.js';
+import { CheckpointManager } from './core/checkpoint-manager.js';
+import { FileGenerator } from './core/file-generator.js';
+import { ReportGenerator, ExecutionReport } from './core/report-generator.js';
+import { NextJSAgent } from './core/nextjs-agent.js';
+import { UIUXAgent } from './core/uiux-agent.js';
+import { BackendAgent } from './core/backend-agent.js';
+import { DatabaseAgent } from './core/database-agent.js';
+import { AIAgentsAgent } from './core/ai-agents-agent.js';
+import { RAGAgent } from './core/rag-agent.js';
+import { PentestAgent } from './core/pentest-agent.js';
+import { DevOpsAgent } from './core/devops-agent.js';
+import { CloudAgent } from './core/cloud-agent.js';
+import { TestingAgent } from './core/testing-agent.js';
+import { CROAgent } from './core/cro-agent.js';
+import { AutomationAgent } from './core/automation-agent.js';
+import { BuildManager } from './core/build-manager.js';
 
 export interface AgentReport {
     agentName: string;
@@ -178,9 +177,10 @@ export class IntelligentOrchestrator {
      * Orquestra uma tarefa completa com aprendizado
      */
     async orchestrateTask(taskDescription: string): Promise<ExecutionResult> {
-        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('🎯 ORQUESTRADOR INTELIGENTE');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('🎯 ORQUESTRADOR INTELIGENTE');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+        console.log(`🧮 Tokens estimados (tarefa): ${this.estimateTokens(taskDescription)}\n`);
 
         const taskId = this.generateTaskId();
         const startTime = Date.now();
@@ -355,14 +355,17 @@ export class IntelligentOrchestrator {
                 }
             }
 
-            console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-            console.log(`${success ? '✅ GO' : '❌ NO-GO'} - Execução ${success ? 'concluída' : 'bloqueada'}`);
-            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-
-            // 6. Coletar feedback (se habilitado)
-            if (this.config.feedbackEnabled) {
-                await this.collectFeedbackForTask(taskId, selectedAgents, taskDescription);
-            }
+            console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log(`${success ? '✅ GO' : '❌ NO-GO'} - Execução ${success ? 'concluída' : 'bloqueada'}`);
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+            console.log('Tem algo a modificar a mais ou posso mandar para o github?');
+            console.log('Por favor, faça um resumo do que foi feito para não perder a memória.');
+
+            // 6. Coletar feedback (se habilitado)
+            if (this.config.feedbackEnabled) {
+                await this.collectFeedbackForTask(taskId, selectedAgents, taskDescription);
+            }
 
             return {
                 success,
@@ -434,17 +437,19 @@ export class IntelligentOrchestrator {
         assignment: AgentAssignment,
         analysis: TaskAnalysis
     ): Promise<AgentReport> {
-        console.log(`━━━ ${assignment.agentName} ━━━`);
-        console.log(`Subtarefa: ${assignment.subtask}\n`);
-
-        try {
-            const context: TaskContext = {
-                files: this.extractFilesForAgent(assignment.agentName, analysis),
-                areas: analysis.detectedAreas,
-                complexity: analysis.complexity,
-            };
-
-            let result: TaskResult;
+        console.log(`━━━ ${assignment.agentName} ━━━`);
+        console.log(`Subtarefa: ${assignment.subtask}\n`);
+        console.log(`🧮 Tokens estimados (subtarefa): ${this.estimateTokens(assignment.subtask)}\n`);
+
+        try {
+            const context: TaskContext = {
+                files: this.extractFilesForAgent(assignment.agentName, analysis),
+                areas: analysis.detectedAreas,
+                complexity: analysis.complexity,
+            };
+
+            const agentInstance = this.getAgentByName(assignment.agentName);
+            let result: TaskResult;
 
             // Iniciar tracking de performance
             const taskId = this.generateTaskId();
@@ -474,8 +479,8 @@ export class IntelligentOrchestrator {
                         case 'documentation-agent':
                             return await this.documentationAgent.executeWithMemory(assignment.subtask, context);
 
-                        case 'inventory-agent':
-                            return await this.inventoryAgent.executeTask(assignment.subtask, context);
+                        case 'inventory-agent':
+                            return await this.inventoryAgent.executeWithMemory(assignment.subtask, context);
 
                         case 'cms-agent':
                             return await this.cmsAgent.executeWithMemory(assignment.subtask, context);
@@ -553,23 +558,41 @@ export class IntelligentOrchestrator {
                     backoffMultiplier: 2
                 },
                 assignment.agentName
-            );
-
-            const status = result.success ? 'success' : 'error';
-
-            // Finalizar tracking de performance
-            this.performanceTracker.endTracking(trackingId, result.success);
+            );
+
+            let status: AgentReport['status'] = result.success ? 'success' : 'error';
+            const blockers: string[] = [...(result.issues || [])];
+
+            if (agentInstance && agentInstance instanceof BaseAgent) {
+                const validator = new WorkflowValidator();
+                const validation = validator.validateAgentExecution(
+                    assignment.agentName,
+                    agentInstance.getWorkflowSteps()
+                );
+                const report = validator.generateValidationReport(assignment.agentName, validation);
+                console.log(report);
+
+                if (!validation.compliant) {
+                    status = 'error';
+                    blockers.push(
+                        `Workflow NON-COMPLIANT: passos faltantes - ${validation.missingSteps.join(', ')}`
+                    );
+                }
+            }
+
+            // Finalizar tracking de performance
+            this.performanceTracker.endTracking(trackingId, result.success);
 
             console.log(`${result.success ? '✅' : '❌'} ${assignment.agentName} concluído\n`);
 
-            return {
-                agentName: assignment.agentName,
-                stepNumber: assignment.priority,
-                status,
-                summary: result.success ? 'Tarefa concluída com sucesso' : 'Tarefa falhou',
-                details: result.details,
-                blockers: result.issues,
-            };
+            return {
+                agentName: assignment.agentName,
+                stepNumber: assignment.priority,
+                status,
+                summary: result.success ? 'Tarefa concluída com sucesso' : 'Tarefa falhou',
+                details: result.details,
+                blockers: blockers.length > 0 ? blockers : undefined,
+            };
 
         } catch (error) {
             console.error(`❌ Erro ao executar ${assignment.agentName}:`, error);
@@ -616,7 +639,7 @@ export class IntelligentOrchestrator {
             complexity: 'low'
         };
 
-        const result = await this.inventoryAgent.executeTask(`check duplication for "${taskDescription}"`, context);
+        const result = await this.inventoryAgent.executeWithMemory(`check duplication for "${taskDescription}"`, context);
 
         if (result.warnings && result.warnings.length > 0) {
             console.log('\n⚠️  ALERTA DE DUPLICAÇÃO DETECTADO:');
@@ -716,6 +739,7 @@ export class IntelligentOrchestrator {
         try {
             // Executar validate
             console.log('   Executando npm run validate...');
+            const { execSync } = await import('child_process');
             execSync('npm run validate', { stdio: 'pipe' });
             console.log('   ✅ Validate passou');
         } catch (error) {
@@ -732,9 +756,15 @@ export class IntelligentOrchestrator {
     /**
      * Gera ID único para tarefa
      */
-    private generateTaskId(): string {
-        return `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
+    private generateTaskId(): string {
+        return `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    private estimateTokens(text: string): number {
+        const normalized = text.trim();
+        if (!normalized) return 0;
+        return Math.ceil(normalized.length / 4);
+    }
 
     /**
      * Método legado para compatibilidade