wegho-agentes 4.0.1 → 5.0.0

package/.agents/orchestrator.ts

@@ -9,37 +9,46 @@
  * - Dar decisão final GO/NO-GO
  */
 
-import { FrontEndAgent } from './core/frontend-agent';
-import { SecurityAgent } from './core/security-agent';
-import { ArchitectureAgent } from './core/architecture-agent';
-import { QualityAgent } from './core/quality-agent';
-import { DocumentationAgent } from './core/documentation-agent';
-import { InventoryAgent } from './core/inventory-agent';
+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';
-import { SEOAgent } from './domains/news/seo-agent';
-import { ProductionControlAgent } from './domains/production/production-control-agent';
-import { RouteAgent } from './domains/logistics/route-agent';
-
-import { TaskAnalyzerAgent, TaskAnalysis, AgentAssignment } from './task-analyzer-agent';
-import { MemorySystem } from './core/memory-system';
-import { FeedbackCollector, UserFeedback } from './core/feedback-collector';
-import { PythonBridge } from './security/python-bridge';
-import { AgentConfig, DEFAULT_CONFIG } from './config';
-import { ProjectContext } from './context-loader';
-import { TaskContext, TaskResult } from './core/base-agent';
-import { RetryUtility } from './core/retry-utility';
-import { AgentParallelizer } from './core/agent-parallelizer';
-
-export interface ImplementationPlan {
-    title: string;
-    description: string;
-    hasUIChanges: boolean;
-    hasDatabaseChanges: boolean;
-    affectedFiles: string[];
-    estimatedComplexity: 'low' | 'medium' | 'high';
-}
+import { CMSAgent } from './domains/news/cms-agent.js';
+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 './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 { 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 { 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;
@@ -50,6 +59,19 @@ export interface AgentReport {
     blockers?: string[];
 }
 
+export interface FinalReport {
+    taskDescription: string;
+    overallSuccess: boolean;
+    agentReports: {
+        agentName: string;
+        stepNumber: number;
+        status: string;
+        summary: string;
+        details?: string;
+        blockers?: string[];
+    }[];
+    buildNumber?: number; // 🆕 Build criado (se houver)
+}
 export interface ExecutionResult {
     success: boolean;
     status: 'GO' | 'NO-GO';
@@ -64,6 +86,7 @@ export class IntelligentOrchestrator {
     private memory: MemorySystem;
     private feedbackCollector: FeedbackCollector;
     private context: ProjectContext;
+    private performanceTracker: PerformanceTracker;
 
     // Core Agents
     private frontendAgent: FrontEndAgent;
@@ -80,6 +103,27 @@ export class IntelligentOrchestrator {
     private productionControlAgent: ProductionControlAgent;
     private routeAgent: RouteAgent;
 
+    // New: Planning, Checkpoint, File Generation, and Reporting
+    private planningAgent: PlanningAgent;
+    private checkpointManager: CheckpointManager;
+    private fileGenerator: FileGenerator;
+    private reportGenerator: ReportGenerator;
+
+    // New: 12 Specialized Agents
+    private nextjsAgent: NextJSAgent;
+    private uiuxAgent: UIUXAgent;
+    private backendAgent: BackendAgent;
+    private databaseAgent: DatabaseAgent;
+    private aiAgentsAgent: AIAgentsAgent;
+    private ragAgent: RAGAgent;
+    private pentestAgent: PentestAgent;
+    private devopsAgent: DevOpsAgent;
+    private cloudAgent: CloudAgent;
+    private testingAgent: TestingAgent;
+    private croAgent: CROAgent;
+    private automationAgent: AutomationAgent;
+    private buildManager: BuildManager;
+
     constructor(context: ProjectContext, config: AgentConfig = DEFAULT_CONFIG) {
         this.context = context;
         this.config = config;
@@ -87,6 +131,7 @@ export class IntelligentOrchestrator {
         this.memory = new MemorySystem(config.memoryPath, config.maxMemoryEntries);
         this.feedbackCollector = new FeedbackCollector(config.memoryPath);
         this.pythonBridge = new PythonBridge();
+        this.performanceTracker = new PerformanceTracker();
 
         // Inicializar todos os agentes com memória
         this.frontendAgent = new FrontEndAgent(config.memoryPath);
@@ -101,6 +146,30 @@ export class IntelligentOrchestrator {
         this.seoAgent = new SEOAgent(config.memoryPath);
         this.productionControlAgent = new ProductionControlAgent(config.memoryPath);
         this.routeAgent = new RouteAgent(config.memoryPath);
+
+        // Inicializar planning, checkpoint, file generation e reporting
+        const projectRoot = process.cwd();
+        this.planningAgent = new PlanningAgent(config.memoryPath, projectRoot);
+        this.checkpointManager = new CheckpointManager(projectRoot);
+        this.fileGenerator = new FileGenerator(projectRoot);
+        this.reportGenerator = new ReportGenerator();
+
+        // Inicializar 12 novos agentes especializados
+        this.nextjsAgent = new NextJSAgent(config.memoryPath);
+        this.uiuxAgent = new UIUXAgent(config.memoryPath);
+        this.backendAgent = new BackendAgent(config.memoryPath);
+        this.databaseAgent = new DatabaseAgent(config.memoryPath);
+        this.aiAgentsAgent = new AIAgentsAgent(config.memoryPath);
+        this.ragAgent = new RAGAgent(config.memoryPath);
+        this.pentestAgent = new PentestAgent(config.memoryPath);
+        this.devopsAgent = new DevOpsAgent(config.memoryPath);
+        this.cloudAgent = new CloudAgent(config.memoryPath);
+        this.testingAgent = new TestingAgent(config.memoryPath);
+        this.croAgent = new CROAgent(config.memoryPath);
+        this.automationAgent = new AutomationAgent(config.memoryPath);
+
+        // Inicializar Build Manager
+        this.buildManager = new BuildManager(projectRoot);
     }
 
     /**
@@ -112,81 +181,174 @@ export class IntelligentOrchestrator {
         console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
 
         const taskId = this.generateTaskId();
+        const startTime = Date.now();
+        let checkpointId: string | null = null;
+        let implementationPlan: ImplementationPlan | null = null;
 
-        // 1. Analisar tarefa
-        console.log('📊 Fase 1: Análise da Tarefa\n');
-        const analysis = await this.taskAnalyzer.analyzeTask(taskDescription, this.config);
+        try {
+            // 1. Analisar tarefa
+            console.log('📊 Fase 1: Análise da Tarefa\n');
+            const analysis = await this.taskAnalyzer.analyzeTask(taskDescription, this.config);
+
+            // 2. NOVO: Criar plano de implementação
+            console.log('\n🏗️  Fase 2: Planejamento Automático\n');
+            implementationPlan = await this.planningAgent.createImplementationPlan(taskDescription);
+
+            // 3. NOVO: Criar checkpoint antes de implementar
+            console.log('\n💾 Fase 3: Criando Checkpoint\n');
+            checkpointId = await this.checkpointManager.createCheckpoint(
+                `pre-implementation-${taskId}`,
+                implementationPlan.files.create.map(f => f.path)
+            );
 
-        // 2. Selecionar melhores agentes baseado em memória
-        console.log('\n🤖 Fase 2: Seleção Inteligente de Agentes\n');
-        const selectedAgents = await this.selectBestAgents(analysis);
+            // 4. NOVO: Implementar arquivos do plano
+            console.log('\n⚙️  Fase 4: Implementação Automática\n');
+            await this.implementPlan(implementationPlan);
 
-        // 3. Executar com agentes selecionados (EM PARALELO)
-        console.log('\n⚙️  Fase 3: Execução com Agentes\n');
+            // 5. NOVO: Validação automática
+            console.log('\n🔍 Fase 5: Validação Automática\n');
+            const validationResult = await this.runValidation();
 
-        // Agrupar agentes para execução paralela
-        const agentGroups = AgentParallelizer.groupAgents(selectedAgents);
-        const timeEstimate = AgentParallelizer.estimateTimeReduction(selectedAgents);
+            if (!validationResult.passed) {
+                throw new Error('Validação falhou: ' + validationResult.errors.join(', '));
+            }
 
-        console.log(`📊 Agentes agrupados em ${agentGroups.length} grupo(s) paralelo(s)`);
-        console.log(`⏱️  Redução estimada de tempo: ${timeEstimate.reduction}% (${timeEstimate.sequential}s → ${timeEstimate.parallel}s)\n`);
+            // 6. Selecionar melhores agentes baseado em memória (para auditoria)
+            console.log('\n🤖 Fase 6: Auditoria com Agentes\n');
+            const selectedAgents = await this.selectBestAgents(analysis);
+
+            // 7. Executar agentes para validação adicional (EM PARALELO)
+            console.log('\n⚙️  Fase 7: Validação por Agentes\n');
+
+            // Agrupar agentes para execução paralela
+            const agentGroups = AgentParallelizer.groupAgents(selectedAgents);
+            const timeEstimate = AgentParallelizer.estimateTimeReduction(selectedAgents);
+
+            console.log(`📊 Agentes agrupados em ${agentGroups.length} grupo(s) paralelo(s)`);
+            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
+            await this.checkDuplicationBeforeExecution(taskDescription);
+
+            // Executar cada grupo em paralelo
+            for (let i = 0; i < agentGroups.length; i++) {
+                const group = agentGroups[i];
+
+                if (group.length === 1) {
+                    console.log(`\n🔹 Grupo ${i + 1}: Executando ${group[0].agentName}`);
+                } else {
+                    console.log(`\n🔸 Grupo ${i + 1}: Executando ${group.length} agentes em paralelo:`);
+                    group.forEach(a => console.log(`   - ${a.agentName}`));
+                }
+
+                // Executar agentes do grupo em paralelo
+                const groupReports = await Promise.all(
+                    group.map(assignment => this.executeWithAgent(assignment, analysis))
+                );
+
+                // 🆕 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);
+                    }
+                }
+
+                reports.push(...groupReports);
+
+                // Verificar se houve erro crítico
+                const hasError = groupReports.some(r => r.status === 'error');
+                if (hasError) {
+                    success = false;
+                    groupReports.forEach(r => {
+                        if (r.blockers) blockers.push(...r.blockers);
+                    });
+                    console.log('\n❌ Erro crítico detectado, parando execução');
+                    break; // Para na primeira falha crítica
+                }
+            }
 
-        const reports: AgentReport[] = [];
-        const blockers: string[] = [];
-        let success = true;
+            // 4. Gerar relatório de performance
+            console.log('\n📊 Relatório de Performance\n');
+            const perfReport = this.performanceTracker.generateReport(taskId);
 
-        // VERIFICAÇÃO ANTI-DUPLICAÇÃO PROATIVA
-        await this.checkDuplicationBeforeExecution(taskDescription);
+            console.log(`⏱️  Duração total: ${(perfReport.totalDuration / 1000).toFixed(2)}s`);
+            console.log(`🤖 Agentes executados: ${perfReport.agentMetrics.size}`);
 
-        // Executar cada grupo em paralelo
-        for (let i = 0; i < agentGroups.length; i++) {
-            const group = agentGroups[i];
+            if (perfReport.bottlenecks.length > 0) {
+                console.log(`\n⚠️  Bottlenecks identificados:`);
+                perfReport.bottlenecks.forEach(name => {
+                    const summary = perfReport.agentMetrics.get(name);
+                    if (summary) {
+                        console.log(`   - ${name}: ${(summary.averageDuration / 1000).toFixed(2)}s (média)`);
+                    }
+                });
+            }
 
-            if (group.length === 1) {
-                console.log(`\n🔹 Grupo ${i + 1}: Executando ${group[0].agentName}`);
-            } else {
-                console.log(`\n🔸 Grupo ${i + 1}: Executando ${group.length} agentes em paralelo:`);
-                group.forEach(a => console.log(`   - ${a.agentName}`));
+            if (perfReport.recommendations.length > 0) {
+                console.log(`\n💡 Recomendações:`);
+                perfReport.recommendations.forEach(rec => console.log(`   ${rec}`));
             }
 
-            // Executar agentes do grupo em paralelo
-            const groupReports = await Promise.all(
-                group.map(assignment => this.executeWithAgent(assignment, analysis))
-            );
+            // 5. Decisão final
+            const status = success ? 'GO' : 'NO-GO';
 
-            reports.push(...groupReports);
+            console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log(`${success ? '✅ GO' : '❌ NO-GO'} - Execução ${success ? 'concluída' : 'bloqueada'}`);
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
 
-            // Verificar se houve erro crítico
-            const hasError = groupReports.some(r => r.status === 'error');
-            if (hasError) {
-                success = false;
-                groupReports.forEach(r => {
-                    if (r.blockers) blockers.push(...r.blockers);
-                });
-                console.log('\n❌ Erro crítico detectado, parando execução');
-                break; // Para na primeira falha crítica
+            // 6. Coletar feedback (se habilitado)
+            if (this.config.feedbackEnabled) {
+                await this.collectFeedbackForTask(taskId, selectedAgents, taskDescription);
             }
-        }
 
-        // 4. Decisão final
-        const status = success ? 'GO' : 'NO-GO';
+            return {
+                success,
+                status,
+                reports,
+                blockers,
+                taskId,
+            };
 
-        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log(`${success ? '✅ GO' : '❌ NO-GO'} - Execução ${success ? 'concluída' : 'bloqueada'}`);
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+        } catch (error) {
+            console.error('\n❌ Erro durante execução:', (error as Error).message);
+
+            // NOVO: Rollback em caso de erro
+            if (checkpointId) {
+                console.log('\n🔄 Fazendo rollback...');
+                try {
+                    await this.checkpointManager.rollback(checkpointId);
+                    console.log('✅ Rollback concluído com sucesso');
+                } catch (rollbackError) {
+                    console.error('❌ Erro no rollback:', (rollbackError as Error).message);
+                }
+            }
 
-        // 5. Coletar feedback (se habilitado)
-        if (this.config.feedbackEnabled) {
-            await this.collectFeedbackForTask(taskId, selectedAgents, taskDescription);
+            return {
+                success: false,
+                status: 'NO-GO',
+                reports: [],
+                blockers: [(error as Error).message],
+                taskId,
+            };
         }
-
-        return {
-            success,
-            status,
-            reports,
-            blockers,
-            taskId,
-        };
     }
 
     /**
@@ -239,6 +401,14 @@ export class IntelligentOrchestrator {
 
             let result: TaskResult;
 
+            // Iniciar tracking de performance
+            const taskId = this.generateTaskId();
+            const trackingId = this.performanceTracker.startTracking(
+                assignment.agentName,
+                taskId,
+                'full-execution'
+            );
+
             // Executar com timeout e retry
             result = await RetryUtility.executeWithTimeoutAndRetry(
                 async () => {
@@ -274,6 +444,43 @@ export class IntelligentOrchestrator {
                         case 'route-agent':
                             return await this.routeAgent.executeWithMemory(assignment.subtask, context);
 
+                        // NEW: 12 Specialized Agents (with Memory System)
+                        case 'nextjs-agent':
+                            return await this.nextjsAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'uiux-agent':
+                            return await this.uiuxAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'backend-agent':
+                            return await this.backendAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'database-agent':
+                            return await this.databaseAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'ai-agents-agent':
+                            return await this.aiAgentsAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'rag-agent':
+                            return await this.ragAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'pentest-agent':
+                            return await this.pentestAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'devops-agent':
+                            return await this.devopsAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'cloud-agent':
+                            return await this.cloudAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'testing-agent':
+                            return await this.testingAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'cro-agent':
+                            return await this.croAgent.executeWithMemory(assignment.subtask, context);
+
+                        case 'automation-agent':
+                            return await this.automationAgent.executeWithMemory(assignment.subtask, context);
+
                         case 'pentesting-agent':
                             // Executar agente Python de pentesting
                             const pentestResult = await this.pythonBridge.executePentesting({
@@ -305,6 +512,9 @@ export class IntelligentOrchestrator {
 
             const status = result.success ? 'success' : 'error';
 
+            // Finalizar tracking de performance
+            this.performanceTracker.endTracking(trackingId, result.success);
+
             console.log(`${result.success ? '✅' : '❌'} ${assignment.agentName} concluído\n`);
 
             return {
@@ -319,6 +529,24 @@ export class IntelligentOrchestrator {
         } catch (error) {
             console.error(`❌ Erro ao executar ${assignment.agentName}:`, error);
 
+            // Finalizar tracking de performance com erro
+            // Note: trackingId pode não existir se erro ocorreu antes do tracking iniciar
+            try {
+                const taskId = this.generateTaskId();
+                const trackingId = this.performanceTracker.startTracking(
+                    assignment.agentName,
+                    taskId,
+                    'full-execution'
+                );
+                this.performanceTracker.endTracking(
+                    trackingId,
+                    false,
+                    error instanceof Error ? error.message : 'Erro desconhecido'
+                );
+            } catch (trackingError) {
+                // Ignorar erros de tracking
+            }
+
             return {
                 agentName: assignment.agentName,
                 stepNumber: assignment.priority,
@@ -410,6 +638,53 @@ export class IntelligentOrchestrator {
         return this.feedbackCollector.generateFeedbackReport(agentName);
     }
 
+    /**
+     * NOVO: Implementa o plano criado pelo planning agent
+     */
+    private async implementPlan(plan: ImplementationPlan): Promise<void> {
+        console.log(`📝 Implementando ${plan.files.create.length} arquivo(s)...\\n`);
+
+        // Criar arquivos
+        for (const file of plan.files.create) {
+            await this.fileGenerator.createFile(file.path, file.type, file.purpose, plan);
+        }
+
+        // Modificar arquivos existentes
+        for (const file of plan.files.modify) {
+            await this.fileGenerator.modifyFile(file.path, file.changes);
+        }
+
+        // Deletar arquivos
+        for (const file of plan.files.delete) {
+            await this.fileGenerator.deleteFile(file);
+        }
+
+        console.log(`\\n✅ Implementação concluída!`);
+    }
+
+    /**
+     * NOVO: Executa validação automática
+     */
+    private async runValidation(): Promise<{ passed: boolean; errors: string[] }> {
+        const errors: string[] = [];
+
+        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) {
+            errors.push('Validate falhou');
+            console.log('   ❌ Validate falhou');
+        }
+
+        return {
+            passed: errors.length === 0,
+            errors
+        };
+    }
+
     /**
      * Gera ID único para tarefa
      */

package/.agents/project-discovery-agent.ts

@@ -11,7 +11,9 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { DomainType } from './config';
+import * as readline from 'readline';
+import { DomainType } from './config.js';
+import { CodeAuditorAgent } from './code-auditor-agent.js';
 
 export interface ProjectProfile {
     isNewProject: boolean;
@@ -41,7 +43,7 @@ export class ProjectDiscoveryAgent {
     private readline: any;
 
     constructor() {
-        this.readline = require('readline').createInterface({
+        this.readline = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
         });
@@ -119,7 +121,6 @@ export class ProjectDiscoveryAgent {
             console.log('🔍 Vou primeiro analisar o código existente para gerar relatório...\n');
 
             // NOVO: Executar auditoria de código para projetos existentes
-            const { CodeAuditorAgent } = require('./code-auditor-agent');
             const auditor = new CodeAuditorAgent();
             const auditReport = await auditor.auditProject();
 

package/.agents/python/analysis_agent.py

@@ -0,0 +1,40 @@
+from base_agent import BaseAgent
+import hashlib
+
+class AnalysisAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("analysis-agent")
+
+    def process(self, payload):
+        """
+        Simple verification task:
+        1. Receive detailed text/data
+        2. Count words
+        3. Generate a hash (proof of processing)
+        """
+        data = payload.get("data", "")
+        mode = payload.get("mode", "default")
+        
+        self.log(f"Processing in mode: {mode}")
+
+        if not isinstance(data, str):
+            data = str(data)
+
+        word_count = len(data.split())
+        char_count = len(data)
+        content_hash = hashlib.md5(data.encode()).hexdigest()
+
+        return {
+            "success": True,
+            "analysis": {
+                "word_count": word_count,
+                "char_count": char_count,
+                "hash": content_hash,
+                "agent_version": "1.0-python"
+            },
+            "message": "Python processing successful"
+        }
+
+if __name__ == "__main__":
+    agent = AnalysisAgent()
+    agent.run()

package/.agents/python/base_agent.py

@@ -0,0 +1,47 @@
+import sys
+import json
+import traceback
+
+class BaseAgent:
+    def __init__(self, name):
+        self.name = name
+
+    def log(self, message):
+        """Log a message to stderr so it doesn't interfere with JSON stdout"""
+        print(f"[LOG] [{self.name}] {message}", file=sys.stderr)
+
+    def process(self, payload):
+        """Override this method to implement agent logic"""
+        raise NotImplementedError("Subclasses must implement process()")
+
+    def run(self):
+        """Main entry point: reads JSON from stdin, processes, prints JSON to stdout"""
+        try:
+            # Read all input from stdin
+            input_data = sys.stdin.read()
+            if not input_data:
+                raise ValueError("No input data received")
+
+            payload = json.loads(input_data)
+            self.log(f"Received payload: {str(payload)[:50]}...")
+
+            # Execute logic
+            result = self.process(payload)
+
+            # Output result as JSON
+            print(json.dumps(result))
+
+        except Exception as e:
+            error_msg = f"Error in {self.name}: {str(e)}\n{traceback.format_exc()}"
+            self.log(error_msg)
+            # Fails gracefully by printing a JSON error
+            print(json.dumps({
+                "success": False,
+                "error": str(e),
+                "details": traceback.format_exc()
+            }))
+            sys.exit(1)
+
+if __name__ == "__main__":
+    # Basic test if run directly
+    print(json.dumps({"status": "BaseAgent ready"}))