wegho-agentes 5.0.0 → 6.0.0

package/.agents/memory/rag-agent/specialty.md

@@ -0,0 +1,13 @@
+# rag-agent - Especialidade
+
+## Responsabilidades
+- Definir responsabilidades específicas
+
+## Expertise
+- Definir áreas de expertise
+
+## Regras
+- Definir regras específicas
+
+## Tarefas Típicas
+- Listar tarefas típicas

package/.agents/memory/security-agent/successes.json

@@ -1,62 +1,62 @@
-[
-  {
-    "id": "1769137691455-ijx16j1pc",
-    "timestamp": "2026-01-23T03:08:11.455Z",
-    "taskDescription": "Inicializar memória do agente",
-    "context": {
-      "files": [],
-      "areas": [
-        "initialization"
-      ],
-      "complexity": "low"
-    },
-    "result": "success",
-    "details": "Nenhuma vulnerabilidade detectada"
-  },
-  {
-    "id": "1769254240571-w5klc3tl1",
-    "timestamp": "2026-01-24T11:30:40.571Z",
-    "taskDescription": "Detectar vulnerabilidades (XSS, CSRF, dados sensíveis)",
-    "context": {
-      "files": [],
-      "areas": [
-        "frontend",
-        "auth",
-        "security"
-      ],
-      "complexity": "medium"
-    },
-    "result": "success",
-    "details": "Nenhuma vulnerabilidade detectada"
-  },
-  {
-    "id": "1769254246021-h513rxol0",
-    "timestamp": "2026-01-24T11:30:46.021Z",
-    "taskDescription": "Detectar vulnerabilidades (XSS, CSRF, dados sensíveis)",
-    "context": {
-      "files": [],
-      "areas": [
-        "frontend",
-        "security"
-      ],
-      "complexity": "medium"
-    },
-    "result": "success",
-    "details": "Nenhuma vulnerabilidade detectada"
-  },
-  {
-    "id": "1769254251458-m6fuqb1wt",
-    "timestamp": "2026-01-24T11:30:51.458Z",
-    "taskDescription": "Detectar vulnerabilidades (XSS, CSRF, dados sensíveis)",
-    "context": {
-      "files": [],
-      "areas": [
-        "frontend",
-        "security"
-      ],
-      "complexity": "medium"
-    },
-    "result": "success",
-    "details": "Nenhuma vulnerabilidade detectada"
-  }
+[
+  {
+    "id": "1769137691455-ijx16j1pc",
+    "timestamp": "2026-01-23T03:08:11.455Z",
+    "taskDescription": "Inicializar memória do agente",
+    "context": {
+      "files": [],
+      "areas": [
+        "initialization"
+      ],
+      "complexity": "low"
+    },
+    "result": "success",
+    "details": "Nenhuma vulnerabilidade detectada"
+  },
+  {
+    "id": "1769254240571-w5klc3tl1",
+    "timestamp": "2026-01-24T11:30:40.571Z",
+    "taskDescription": "Detectar vulnerabilidades (XSS, CSRF, dados sensíveis)",
+    "context": {
+      "files": [],
+      "areas": [
+        "frontend",
+        "auth",
+        "security"
+      ],
+      "complexity": "medium"
+    },
+    "result": "success",
+    "details": "Nenhuma vulnerabilidade detectada"
+  },
+  {
+    "id": "1769254246021-h513rxol0",
+    "timestamp": "2026-01-24T11:30:46.021Z",
+    "taskDescription": "Detectar vulnerabilidades (XSS, CSRF, dados sensíveis)",
+    "context": {
+      "files": [],
+      "areas": [
+        "frontend",
+        "security"
+      ],
+      "complexity": "medium"
+    },
+    "result": "success",
+    "details": "Nenhuma vulnerabilidade detectada"
+  },
+  {
+    "id": "1769254251458-m6fuqb1wt",
+    "timestamp": "2026-01-24T11:30:51.458Z",
+    "taskDescription": "Detectar vulnerabilidades (XSS, CSRF, dados sensíveis)",
+    "context": {
+      "files": [],
+      "areas": [
+        "frontend",
+        "security"
+      ],
+      "complexity": "medium"
+    },
+    "result": "success",
+    "details": "Nenhuma vulnerabilidade detectada"
+  }
 ]

package/.agents/memory/testing-agent/specialty.md

@@ -0,0 +1,13 @@
+# testing-agent - Especialidade
+
+## Responsabilidades
+- Definir responsabilidades específicas
+
+## Expertise
+- Definir áreas de expertise
+
+## Regras
+- Definir regras específicas
+
+## Tarefas Típicas
+- Listar tarefas típicas

package/.agents/memory/uiux-agent/specialty.md

@@ -0,0 +1,13 @@
+# uiux-agent - Especialidade
+
+## Responsabilidades
+- Definir responsabilidades específicas
+
+## Expertise
+- Definir áreas de expertise
+
+## Regras
+- Definir regras específicas
+
+## Tarefas Típicas
+- Listar tarefas típicas

package/.agents/orchestrator.ts

@@ -28,7 +28,7 @@ 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 { TaskContext, TaskResult } from './core/base-agent.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';
@@ -184,6 +184,7 @@ export class IntelligentOrchestrator {
         const startTime = Date.now();
         let checkpointId: string | null = null;
         let implementationPlan: ImplementationPlan | null = null;
+        const blockers: string[] = [];
 
         try {
             // 1. Analisar tarefa
@@ -210,7 +211,9 @@ export class IntelligentOrchestrator {
             const validationResult = await this.runValidation();
 
             if (!validationResult.passed) {
-                throw new Error('Validação falhou: ' + validationResult.errors.join(', '));
+                console.log('⚠️  Validação falhou, mas prosseguindo para auditoria completa...');
+                validationResult.errors.forEach(err => blockers.push(err));
+                // Não lançar erro para permitir que os agentes de auditoria (Fase 6/7) rodem
             }
 
             // 6. Selecionar melhores agentes baseado em memória (para auditoria)
@@ -228,7 +231,6 @@ export class IntelligentOrchestrator {
             console.log(`⏱️  Redução estimada de tempo: ${timeEstimate.reduction}% (${timeEstimate.sequential}s → ${timeEstimate.parallel}s)\n`);
 
             const reports: AgentReport[] = [];
-            const blockers: string[] = [];
             let success = true;
 
             // VERIFICAÇÃO ANTI-DUPLICAÇÃO PROATIVA
@@ -252,22 +254,26 @@ export class IntelligentOrchestrator {
 
                 // 🆕 CRIAR BUILD se houve mudanças bem-sucedidas
                 const successfulAgents = groupReports.filter(r => r.status === 'success');
-                if (successfulAgents.length > 0 && implementationPlan?.files.create.length > 0) { // Assuming context.files refers to the files from the implementation plan
-                    try {
-                        const buildNumber = await this.buildManager.createBuild(
-                            implementationPlan.files.create.map(f => f.path), // Use files from implementation plan
-                            `orchestrator (${successfulAgents.map(a => a.agentName).join(', ')})`,
-                            true,
-                            taskDescription // Pass taskDescription instead of 'task'
-                        );
-                        console.log(`\n📦 Build ${buildNumber} criado automaticamente`);
-                        console.log(`   Arquivos rastreados: ${implementationPlan.files.create.length}`);
-                        console.log(`   Agentes envolvidos: ${successfulAgents.length}`);
-
-                        // Adicionar informação do build ao report (assuming AgentReport can be extended or a separate report is generated later)
-                        // For now, just log it. If a final report object is built, this info can be added there.
-                    } catch (error) {
-                        console.warn('⚠️  Erro ao criar build:', error);
+                if (successfulAgents.length > 0 && implementationPlan) {
+                    const allFiles = [
+                        ...implementationPlan.files.create.map(f => f.path),
+                        ...implementationPlan.files.modify.map(f => f.path)
+                    ];
+
+                    if (allFiles.length > 0) {
+                        try {
+                            const buildNumber = await this.buildManager.createBuild(
+                                allFiles,
+                                `orchestrator (${successfulAgents.map(a => a.agentName).join(', ')})`,
+                                true,
+                                taskDescription
+                            );
+                            console.log(`\n📦 Build ${buildNumber} criado automaticamente`);
+                            console.log(`   Arquivos rastreados: ${allFiles.length}`);
+                            console.log(`   Agentes envolvidos: ${successfulAgents.map(a => a.agentName).join(', ')}`);
+                        } catch (error) {
+                            console.warn('⚠️  Erro ao criar build:', error);
+                        }
                     }
                 }
 
@@ -310,6 +316,43 @@ export class IntelligentOrchestrator {
             // 5. Decisão final
             const status = success ? 'GO' : 'NO-GO';
 
+            // 🆕 APRENDIZADO AUTOMÁTICO: Atualizar memória dos agentes baseados no resultado FINAL (Build/Audit)
+            console.log('\n🧠 Fase Final: Sincronizando Memória e Aprendizado...');
+            for (const report of reports) {
+                const agent = this.getAgentByName(report.agentName);
+                if (agent && agent instanceof BaseAgent) {
+                    const finalSuccess = success && report.status === 'success';
+                    const context: TaskContext = {
+                        files: implementationPlan?.files.create.map(f => f.path) || [],
+                        areas: analysis.detectedAreas,
+                        complexity: analysis.complexity,
+                    };
+
+                    // Se o projeto falhou no build/audit, o agente "falhou" em garantir a integridade global
+                    await agent.recordOutcome(
+                        report.summary,
+                        context,
+                        { success: finalSuccess, details: report.details },
+                        {
+                            satisfied: finalSuccess,
+                            likes: finalSuccess ? ['Passou na validação final'] : [],
+                            dislikes: !finalSuccess ? ['Falhou na validação global ou audit'] : [],
+                            suggestions: !finalSuccess ? ['Revisar integração com o sistema de build'] : []
+                        }
+                    );
+
+                    if (finalSuccess) {
+                        // Promover a aprendizado automático se teve sucesso
+                        await agent.learn(
+                            taskDescription,
+                            `Implementação bem-sucedida de: ${taskDescription}`,
+                            `Repetir padrões usados em: ${implementationPlan?.title}`,
+                            [this.generateTaskId()]
+                        );
+                    }
+                }
+            }
+
             console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
             console.log(`${success ? '✅ GO' : '❌ NO-GO'} - Execução ${success ? 'concluída' : 'bloqueada'}`);
             console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
@@ -707,6 +750,37 @@ export class IntelligentOrchestrator {
         const taskDescription = `${plan.title}: ${plan.description}`;
         return await this.orchestrateTask(taskDescription);
     }
+
+    /**
+     * Retorna a instância de um agente pelo nome
+     */
+    private getAgentByName(name: string): any {
+        const agentsMap: Record<string, any> = {
+            'frontend-agent': this.frontendAgent,
+            'security-agent': this.securityAgent,
+            'architecture-agent': this.architectureAgent,
+            'quality-agent': this.qualityAgent,
+            'documentation-agent': this.documentationAgent,
+            'inventory-agent': this.inventoryAgent,
+            'cms-agent': this.cmsAgent,
+            'seo-agent': this.seoAgent,
+            'production-control-agent': this.productionControlAgent,
+            'route-agent': this.routeAgent,
+            'nextjs-agent': this.nextjsAgent,
+            'uiux-agent': this.uiuxAgent,
+            'backend-agent': this.backendAgent,
+            'database-agent': this.databaseAgent,
+            'ai-agents-agent': this.aiAgentsAgent,
+            'rag-agent': this.ragAgent,
+            'pentest-agent': this.pentestAgent,
+            'devops-agent': this.devopsAgent,
+            'cloud-agent': this.cloudAgent,
+            'testing-agent': this.testingAgent,
+            'cro-agent': this.croAgent,
+            'automation-agent': this.automationAgent
+        };
+        return agentsMap[name];
+    }
 }
 
 // Manter compatibilidade com código existente

package/.agents/validate.ts

@@ -44,6 +44,8 @@ async function validateProject(): Promise<ValidationResult> {
             '.next/**',
             'dist/**',
             'build/**',
+            '.agents/**', // Agentes são neutros e isentos do limite de linhas
+            'scripts/**', // Scripts de teste/utilitários são isentos
             '.agents/memory/**',
             'coverage/**'
         ]
@@ -51,10 +53,25 @@ async function validateProject(): Promise<ValidationResult> {
 
     let filesOverLimit = 0;
     for (const file of filesToCheck) {
+        // Ignore agents, scripts, node_modules, skills anywhere in the path if they are part of the system
+        const lowerFile = file.toLowerCase().replace(/\\/g, '/');
+        if (
+            lowerFile.includes('/node_modules/') ||
+            lowerFile.startsWith('.agents/') ||
+            lowerFile.includes('/.agents/') ||
+            lowerFile.startsWith('scripts/') ||
+            lowerFile.includes('/scripts/') ||
+            lowerFile.startsWith('skills/') ||
+            lowerFile.includes('/skills/')
+        ) {
+            continue;
+        }
+
         const fullPath = path.join(projectRoot, file);
         const validation = validateFileLines(fullPath, 500);
 
         if (!validation.valid) {
+            console.log(`  ❌ ${file} excede o limite: ${validation.lineCount} linhas`);
             result.errors.push(validation.message || `${file} excede 500 linhas`);
             filesOverLimit++;
             result.passed = false;