wegho-agentes 4.0.1 → 5.0.0

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

@@ -0,0 +1,388 @@
+import { BaseAgent, TaskContext, TaskResult } from './base-agent.js';
+import { InventoryAgent } from './inventory-agent.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Planning Agent - Cria planos de implementação automáticos
+ * 
+ * Responsabilidades:
+ * - Analisar tarefa e criar plano detalhado
+ * - Definir arquitetura de solução
+ * - Listar arquivos a criar/modificar
+ * - Estimar esforço e complexidade
+ * - Validar viabilidade técnica
+ */
+
+export interface ImplementationPlan {
+    title: string;
+    description: string;
+    architecture: {
+        components: string[];
+        apis: string[];
+        database: string[];
+        dependencies: string[];
+    };
+    files: {
+        create: Array<{
+            path: string;
+            type: 'component' | 'api' | 'hook' | 'util' | 'type' | 'config';
+            purpose: string;
+        }>;
+        modify: Array<{
+            path: string;
+            changes: string;
+        }>;
+        delete: string[];
+    };
+    steps: string[];
+    estimatedTime: string;
+    complexity: 'low' | 'medium' | 'high';
+    risks: string[];
+    dependencies: string[];
+}
+
+export class PlanningAgent extends BaseAgent {
+    private inventoryAgent: InventoryAgent;
+    private projectRoot: string;
+
+    constructor(memoryPath: string, projectRoot: string = process.cwd()) {
+        super('planning-agent', memoryPath);
+        this.projectRoot = projectRoot;
+        this.inventoryAgent = new InventoryAgent(projectRoot, memoryPath);
+    }
+
+    /**
+     * Cria um plano de implementação completo
+     */
+    async createImplementationPlan(taskDescription: string): Promise<ImplementationPlan> {
+        console.log('\n🏗️  Criando plano de implementação...\n');
+
+        // 1. Analisar tarefa
+        const taskAnalysis = this.analyzeTask(taskDescription);
+
+        // 2. Consultar inventário para entender projeto
+        const inventory = await this.consultInventory();
+
+        // 3. Definir arquitetura
+        const architecture = this.defineArchitecture(taskAnalysis, inventory);
+
+        // 4. Planejar arquivos
+        const files = this.planFiles(taskAnalysis, architecture, inventory);
+
+        // 5. Criar passos de execução
+        const steps = this.createExecutionSteps(architecture, files);
+
+        // 6. Estimar esforço
+        const { estimatedTime, complexity } = this.estimateEffort(files, architecture);
+
+        // 7. Identificar riscos
+        const risks = this.identifyRisks(taskAnalysis, architecture);
+
+        // 8. Listar dependências
+        const dependencies = this.listDependencies(architecture);
+
+        const plan: ImplementationPlan = {
+            title: taskAnalysis.title,
+            description: taskAnalysis.description,
+            architecture,
+            files,
+            steps,
+            estimatedTime,
+            complexity,
+            risks,
+            dependencies
+        };
+
+        // Exibir plano
+        this.displayPlan(plan);
+
+        return plan;
+    }
+
+    /**
+     * Analisa a tarefa e extrai informações chave
+     */
+    private analyzeTask(taskDescription: string): {
+        title: string;
+        description: string;
+        type: string;
+        keywords: string[];
+    } {
+        const lower = taskDescription.toLowerCase();
+
+        // Detectar tipo de tarefa
+        let type = 'feature';
+        if (lower.includes('criar') || lower.includes('adicionar')) type = 'create';
+        if (lower.includes('modificar') || lower.includes('atualizar')) type = 'update';
+        if (lower.includes('remover') || lower.includes('deletar')) type = 'delete';
+        if (lower.includes('corrigir') || lower.includes('bug')) type = 'fix';
+
+        // Extrair keywords importantes
+        const keywords: string[] = [];
+        if (lower.includes('autenticação') || lower.includes('login')) keywords.push('auth');
+        if (lower.includes('dashboard') || lower.includes('painel')) keywords.push('dashboard');
+        if (lower.includes('formulário') || lower.includes('form')) keywords.push('form');
+        if (lower.includes('api') || lower.includes('endpoint')) keywords.push('api');
+        if (lower.includes('banco') || lower.includes('database')) keywords.push('database');
+        if (lower.includes('componente') || lower.includes('component')) keywords.push('component');
+
+        return {
+            title: this.extractTitle(taskDescription),
+            description: taskDescription,
+            type,
+            keywords
+        };
+    }
+
+    /**
+     * Extrai título da tarefa
+     */
+    private extractTitle(taskDescription: string): string {
+        // Remove palavras de ação e retorna o resto
+        return taskDescription
+            .replace(/^(criar|adicionar|modificar|atualizar|remover|deletar|corrigir)\s+/i, '')
+            .trim()
+            .split(' ')
+            .slice(0, 5)
+            .join(' ');
+    }
+
+    /**
+     * Consulta inventário do projeto
+     */
+    private async consultInventory(): Promise<any> {
+        try {
+            const inventoryPath = path.join(this.projectRoot, '.agents', 'memory', 'inventory-agent', 'inventory');
+
+            if (!fs.existsSync(inventoryPath)) {
+                return { components: [], apis: [], types: [] };
+            }
+
+            const components = this.loadInventoryFile(path.join(inventoryPath, 'components.json'));
+            const apis = this.loadInventoryFile(path.join(inventoryPath, 'endpoints.json'));
+            const types = this.loadInventoryFile(path.join(inventoryPath, 'types.json'));
+
+            return { components, apis, types };
+        } catch (error) {
+            console.warn('⚠️  Não foi possível carregar inventário completo');
+            return { components: [], apis: [], types: [] };
+        }
+    }
+
+    /**
+     * Carrega arquivo de inventário
+     */
+    private loadInventoryFile(filePath: string): any[] {
+        try {
+            if (fs.existsSync(filePath)) {
+                return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            }
+        } catch (error) {
+            // Ignora erro
+        }
+        return [];
+    }
+
+    /**
+     * Define arquitetura da solução
+     */
+    private defineArchitecture(taskAnalysis: any, inventory: any): ImplementationPlan['architecture'] {
+        const architecture: ImplementationPlan['architecture'] = {
+            components: [],
+            apis: [],
+            database: [],
+            dependencies: []
+        };
+
+        // Baseado nas keywords, definir componentes necessários
+        if (taskAnalysis.keywords.includes('auth')) {
+            architecture.components.push('AuthProvider', 'LoginForm', 'ProtectedRoute');
+            architecture.apis.push('/api/auth/login', '/api/auth/logout', '/api/auth/session');
+            architecture.database.push('users', 'sessions');
+            architecture.dependencies.push('@supabase/auth-helpers-nextjs');
+        }
+
+        if (taskAnalysis.keywords.includes('dashboard')) {
+            architecture.components.push('DashboardLayout', 'StatsCard', 'ChartWidget');
+            architecture.apis.push('/api/dashboard/stats');
+        }
+
+        if (taskAnalysis.keywords.includes('form')) {
+            architecture.components.push('FormComponent', 'FormField', 'FormValidation');
+            architecture.dependencies.push('react-hook-form', 'zod');
+        }
+
+        return architecture;
+    }
+
+    /**
+     * Planeja arquivos a criar/modificar
+     */
+    private planFiles(taskAnalysis: any, architecture: any, inventory: any): ImplementationPlan['files'] {
+        const files: ImplementationPlan['files'] = {
+            create: [],
+            modify: [],
+            delete: []
+        };
+
+        // Criar componentes
+        for (const component of architecture.components) {
+            files.create.push({
+                path: `components/${component}.tsx`,
+                type: 'component',
+                purpose: `Componente ${component}`
+            });
+        }
+
+        // Criar APIs
+        for (const api of architecture.apis) {
+            const apiPath = api.replace('/api/', 'app/api/') + '/route.ts';
+            files.create.push({
+                path: apiPath,
+                type: 'api',
+                purpose: `Endpoint ${api}`
+            });
+        }
+
+        // Modificar layout se necessário
+        if (architecture.components.length > 0) {
+            files.modify.push({
+                path: 'app/layout.tsx',
+                changes: 'Adicionar providers necessários'
+            });
+        }
+
+        return files;
+    }
+
+    /**
+     * Cria passos de execução
+     */
+    private createExecutionSteps(architecture: any, files: any): string[] {
+        const steps: string[] = [];
+
+        if (architecture.database.length > 0) {
+            steps.push('1. Criar/atualizar tabelas no banco de dados');
+        }
+
+        if (architecture.dependencies.length > 0) {
+            steps.push('2. Instalar dependências necessárias');
+        }
+
+        if (files.create.length > 0) {
+            steps.push('3. Criar novos arquivos');
+        }
+
+        if (files.modify.length > 0) {
+            steps.push('4. Modificar arquivos existentes');
+        }
+
+        steps.push('5. Validar implementação');
+        steps.push('6. Executar testes');
+
+        return steps;
+    }
+
+    /**
+     * Estima esforço necessário
+     */
+    private estimateEffort(files: any, architecture: any): { estimatedTime: string; complexity: 'low' | 'medium' | 'high' } {
+        const totalFiles = files.create.length + files.modify.length;
+        const hasDatabaseChanges = architecture.database.length > 0;
+        const hasAPIs = architecture.apis.length > 0;
+
+        let minutes = totalFiles * 5; // 5min por arquivo base
+
+        if (hasDatabaseChanges) minutes += 15;
+        if (hasAPIs) minutes += totalFiles * 3;
+
+        let complexity: 'low' | 'medium' | 'high' = 'low';
+        if (totalFiles > 5 || hasDatabaseChanges) complexity = 'medium';
+        if (totalFiles > 10 || (hasDatabaseChanges && hasAPIs)) complexity = 'high';
+
+        return {
+            estimatedTime: `${minutes}min`,
+            complexity
+        };
+    }
+
+    /**
+     * Identifica riscos potenciais
+     */
+    private identifyRisks(taskAnalysis: any, architecture: any): string[] {
+        const risks: string[] = [];
+
+        if (architecture.database.length > 0) {
+            risks.push('Mudanças no banco de dados podem afetar dados existentes');
+        }
+
+        if (architecture.apis.length > 3) {
+            risks.push('Múltiplos endpoints podem ter impacto em performance');
+        }
+
+        if (architecture.dependencies.length > 0) {
+            risks.push('Novas dependências aumentam bundle size');
+        }
+
+        return risks;
+    }
+
+    /**
+     * Lista dependências necessárias
+     */
+    private listDependencies(architecture: any): string[] {
+        return architecture.dependencies || [];
+    }
+
+    /**
+     * Exibe plano formatado
+     */
+    private displayPlan(plan: ImplementationPlan): void {
+        console.log(`📋 Título: ${plan.title}`);
+        console.log(`📝 Descrição: ${plan.description}`);
+        console.log(`⏱️  Tempo estimado: ${plan.estimatedTime}`);
+        console.log(`🎯 Complexidade: ${plan.complexity.toUpperCase()}\n`);
+
+        console.log('🏗️  Arquitetura:');
+        if (plan.architecture.components.length > 0) {
+            console.log(`   Componentes: ${plan.architecture.components.join(', ')}`);
+        }
+        if (plan.architecture.apis.length > 0) {
+            console.log(`   APIs: ${plan.architecture.apis.join(', ')}`);
+        }
+        if (plan.architecture.database.length > 0) {
+            console.log(`   Banco: ${plan.architecture.database.join(', ')}`);
+        }
+
+        console.log(`\n📁 Arquivos (${plan.files.create.length} criar, ${plan.files.modify.length} modificar):`);
+        plan.files.create.slice(0, 5).forEach(f => console.log(`   ✨ ${f.path}`));
+        if (plan.files.create.length > 5) {
+            console.log(`   ... e mais ${plan.files.create.length - 5} arquivo(s)`);
+        }
+
+        if (plan.risks.length > 0) {
+            console.log(`\n⚠️  Riscos:`);
+            plan.risks.forEach(r => console.log(`   - ${r}`));
+        }
+
+        console.log('');
+    }
+
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        try {
+            const plan = await this.createImplementationPlan(taskDescription);
+
+            return {
+                success: true,
+                details: `Plano criado: ${plan.files.create.length} arquivos a criar`,
+                recommendations: plan.steps
+            };
+        } catch (error) {
+            return {
+                success: false,
+                details: `Erro ao criar plano: ${(error as Error).message}`
+            };
+        }
+    }
+}

package/.agents/core/python-bridge.ts

@@ -0,0 +1,94 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+
+export interface PythonExecutionResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    logs: string[];
+}
+
+export class PythonBridge {
+    private pythonPath: string;
+    private scriptsPath: string;
+
+    constructor(pythonPath: string = 'python', scriptsPath: string = '.agents/python') {
+        this.pythonPath = pythonPath;
+        this.scriptsPath = path.resolve(process.cwd(), scriptsPath);
+    }
+
+    /**
+     * Excecute a Python agent script
+     * @param scriptName Name of the script (e.g., 'analysis_agent.py')
+     * @param payload JSON payload to pass to the script
+     */
+    async execute(scriptName: string, payload: any): Promise<PythonExecutionResult> {
+        return new Promise((resolve, reject) => {
+            const scriptFullPath = path.join(this.scriptsPath, scriptName);
+            const logs: string[] = [];
+
+            const pythonProcess = spawn(this.pythonPath, [scriptFullPath]);
+
+            let outputData = '';
+            let errorData = '';
+
+            // Send payload to stdin
+            pythonProcess.stdin.write(JSON.stringify(payload));
+            pythonProcess.stdin.end();
+
+            pythonProcess.stdout.on('data', (data) => {
+                const str = data.toString();
+                outputData += str;
+                // Try to capture logs if mixed in output (simple heuristic)
+                if (str.startsWith('[LOG]')) {
+                    logs.push(str.trim());
+                }
+            });
+
+            pythonProcess.stderr.on('data', (data) => {
+                const str = data.toString();
+                errorData += str;
+                logs.push(`[STDERR] ${str.trim()}`);
+            });
+
+            pythonProcess.on('close', (code) => {
+                if (code !== 0) {
+                    resolve({
+                        success: false,
+                        error: `Process exited with code ${code}. Error: ${errorData}`,
+                        logs,
+                    });
+                    return;
+                }
+
+                try {
+                    // Try to find the last JSON line in the output
+                    // Python scripts should print the JSON result as the last line
+                    const lines = outputData.trim().split('\n');
+                    const lastLine = lines[lines.length - 1];
+                    const result = JSON.parse(lastLine);
+
+                    resolve({
+                        success: true,
+                        data: result,
+                        logs
+                    });
+                } catch (e) {
+                    resolve({
+                        success: false,
+                        error: `Failed to parse Python output: ${(e as Error).message}. Raw output: ${outputData}`,
+                        logs
+                    });
+                }
+            });
+
+            pythonProcess.on('error', (err) => {
+                resolve({
+                    success: false,
+                    error: `Failed to spawn Python process: ${err.message}`,
+                    logs
+                });
+            });
+        });
+    }
+}

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

@@ -12,7 +12,7 @@
 
 import { spawn } from 'child_process';
 import * as fs from 'fs';
-import { BaseAgent, TaskContext, TaskResult } from './base-agent';
+import { BaseAgent, TaskContext, TaskResult } from './base-agent.js';
 
 export interface QualityCheckResult extends TaskResult {
     checks: {

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

@@ -0,0 +1,84 @@
+import { BaseAgent, TaskContext, TaskResult } from './base-agent.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * RAG Agent - Especialista em Retrieval-Augmented Generation
+ * 
+ * Responsabilidades:
+ * - RAG implementation
+ * - Vector databases
+ * - Embedding strategies
+ * - LLM integration
+ * 
+ * Skills: rag-implementation, rag-engineer, llm-app-patterns,
+ *         langfuse, langgraph
+ */
+
+export class RAGAgent extends BaseAgent {
+    private skillsPath: string;
+
+    constructor(memoryPath: string) {
+        super('rag-agent', memoryPath);
+        this.skillsPath = path.join(process.cwd(), 'skills');
+    }
+
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        console.log(`\n📚 RAG Agent analisando tarefa...\n`);
+
+        const issues: string[] = [];
+        const recommendations: string[] = [];
+
+        // Análise de RAG Implementation
+        if (taskDescription.toLowerCase().includes('rag') ||
+            taskDescription.toLowerCase().includes('retrieval')) {
+
+            recommendations.push('✅ Escolher vector database adequado (Pinecone, Weaviate, Qdrant)');
+            recommendations.push('✅ Implementar chunking strategy eficiente');
+            recommendations.push('✅ Usar embeddings de qualidade (OpenAI, Cohere)');
+            recommendations.push('✅ Implementar hybrid search (vector + keyword)');
+            recommendations.push('✅ Adicionar reranking para melhor relevância');
+        }
+
+        // Análise de Vector Database
+        if (taskDescription.toLowerCase().includes('vector') ||
+            taskDescription.toLowerCase().includes('embedding')) {
+
+            recommendations.push('✅ Definir dimensão de embeddings adequada');
+            recommendations.push('✅ Criar índices otimizados');
+            recommendations.push('✅ Implementar metadata filtering');
+            recommendations.push('✅ Usar batch operations para performance');
+        }
+
+        // Análise de LLM Integration
+        if (taskDescription.toLowerCase().includes('llm') ||
+            taskDescription.toLowerCase().includes('language model')) {
+
+            recommendations.push('✅ Implementar prompt templates');
+            recommendations.push('✅ Usar context window eficientemente');
+            recommendations.push('✅ Adicionar fallback para rate limits');
+            recommendations.push('✅ Implementar caching de respostas');
+        }
+
+        // Análise de Observability
+        if (taskDescription.toLowerCase().includes('observability') ||
+            taskDescription.toLowerCase().includes('monitoring')) {
+
+            recommendations.push('✅ Usar Langfuse para tracing');
+            recommendations.push('✅ Monitorar custos de API');
+            recommendations.push('✅ Rastrear quality metrics');
+            recommendations.push('✅ Implementar feedback loops');
+        }
+
+        const success = issues.length === 0;
+
+        return {
+            success,
+            details: success
+                ? `RAG Agent: ${recommendations.length} recomendações`
+                : `RAG Agent: ${issues.length} problemas encontrados`,
+            recommendations,
+            blockers: issues
+        };
+    }
+}