wegho-agentes 4.0.1

package/.agents/context-loader.ts

@@ -0,0 +1,300 @@
+/**
+ * Context Loader - Sistema "Iniciar Contexto"
+ * 
+ * Carrega toda a base de conhecimento do projeto antes de iniciar qualquer implementação:
+ * - DESIGN_SYSTEM.md
+ * - SYMBOLS_TREE.md
+ * - BUILD_HISTORY.md
+ * - AGENT_RULES.md
+ * - Build atual (build-XXX.md)
+ * - Regras do usuário (MEMORY)
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { PATHS, detectDomain, DomainConfig, getCurrentBuildNumber } from './config';
+import { ProjectDiscoveryAgent } from './project-discovery-agent';
+
+export interface ProjectContext {
+    designSystem: string;
+    symbolsTree: string;
+    buildHistory: string;
+    agentRules: string;
+    currentBuild: string | null;
+    domainConfig: DomainConfig;
+    timestamp: string;
+    projectProfile?: any; // ProjectProfile do discovery
+}
+
+/**
+ * Carrega o conteúdo de um arquivo markdown
+ */
+function loadMarkdown(filePath: string): string {
+    try {
+        const fullPath = path.resolve(process.cwd(), filePath);
+        if (fs.existsSync(fullPath)) {
+            return fs.readFileSync(fullPath, 'utf-8');
+        }
+        console.warn(`⚠️ Arquivo não encontrado: ${filePath}`);
+        return '';
+    } catch (error) {
+        console.error(`❌ Erro ao carregar ${filePath}:`, error);
+        return '';
+    }
+}
+
+/**
+ * Carrega o arquivo de build atual
+ */
+function loadCurrentBuild(): string | null {
+    const buildNumber = getCurrentBuildNumber();
+    const buildPath = `${PATHS.builds}/build-${String(buildNumber).padStart(3, '0')}.md`;
+
+    if (fs.existsSync(buildPath)) {
+        return loadMarkdown(buildPath);
+    }
+
+    console.log(`ℹ️ Build atual (build-${buildNumber}) ainda não existe. Será criado ao finalizar a primeira tarefa.`);
+    return null;
+}
+
+/**
+ * Executa pré-verificações do projeto
+ */
+async function runPreChecks(): Promise<{ success: boolean; issues: string[] }> {
+    const issues: string[] = [];
+
+    // Verificar se estrutura de documentação existe
+    if (!fs.existsSync(PATHS.docs)) {
+        issues.push('⚠️ Diretório docs/ não encontrado');
+    }
+
+    if (!fs.existsSync(PATHS.designSystem)) {
+        issues.push('⚠️ DESIGN_SYSTEM.md não encontrado');
+    }
+
+    if (!fs.existsSync(PATHS.symbolsTree)) {
+        issues.push('⚠️ SYMBOLS_TREE.md não encontrado');
+    }
+
+    if (!fs.existsSync(PATHS.buildHistory)) {
+        issues.push('⚠️ BUILD_HISTORY.md não encontrado');
+    }
+
+    if (!fs.existsSync(PATHS.agentRules)) {
+        issues.push('⚠️ AGENT_RULES.md não encontrado');
+    }
+
+    // Verificar package.json
+    if (!fs.existsSync('package.json')) {
+        issues.push('⚠️ package.json não encontrado');
+    }
+
+    return {
+        success: issues.length === 0,
+        issues,
+    };
+}
+
+/**
+ * FUNÇÃO PRINCIPAL: Inicializar Contexto
+ * 
+ * Chamada quando o usuário escreve "inicie o contexto"
+ */
+export async function initializeContext(interactive: boolean = true): Promise<ProjectContext> {
+    let projectProfile: any;
+
+    // NOVO: Descoberta interativa do projeto
+    if (interactive) {
+        const discovery = new ProjectDiscoveryAgent();
+        const isNewProject = discovery.detectNewProject();
+
+        if (isNewProject) {
+            console.log('✨ Projeto novo detectado!\n');
+            console.log('Vamos fazer algumas perguntas para configurar os agentes ideais...\n');
+
+            // Executar descoberta interativa
+            projectProfile = await discovery.discoverProject();
+
+            // Gerar recomendações
+            const recommendations = discovery.generateRecommendations(projectProfile);
+
+            // Mostrar relatório
+            const report = discovery.generateReport(projectProfile, recommendations);
+            console.log(report);
+
+            // Salvar perfil
+            discovery.saveProfile(projectProfile);
+
+            // TODO: Auto-criar agentes recomendados com autoCreate: true
+            console.log('🚀 Criando agentes recomendados...\n');
+            // (implementação futura)
+        } else {
+            console.log('📦 Projeto existente detectado. Carregando perfil...\n');
+
+            // Tentar carregar perfil existente
+            if (fs.existsSync('docs/PROJECT_PROFILE.json')) {
+                projectProfile = JSON.parse(fs.readFileSync('docs/PROJECT_PROFILE.json', 'utf-8'));
+                console.log(`✅ Perfil carregado: ${projectProfile.projectName}\n`);
+            }
+        }
+    }
+
+    // Passo 1: Executar pré-verificações
+    console.log('📋 Verificando estrutura do projeto...');
+    const preCheckResult = await runPreChecks();
+
+    if (!preCheckResult.success) {
+        console.warn('\n⚠️ Avisos encontrados:');
+        preCheckResult.issues.forEach((issue) => console.warn(`  ${issue}`));
+        console.log('');
+    } else {
+        console.log('  ✅ Estrutura do projeto OK\n');
+    }
+
+    // Passo 2: Carregar documentação base
+    console.log('📚 Carregando documentação base...');
+    const designSystem = loadMarkdown(PATHS.designSystem);
+    const symbolsTree = loadMarkdown(PATHS.symbolsTree);
+    const buildHistory = loadMarkdown(PATHS.buildHistory);
+    const agentRules = loadMarkdown(PATHS.agentRules);
+    console.log('  ✅ Documentação carregada\n');
+
+    // Passo 3: Carregar build atual 
+    console.log('📦 Carregando build atual...');
+    const currentBuild = loadCurrentBuild();
+    console.log(`  ${currentBuild ? '✅' : 'ℹ️'} Build atual ${currentBuild ? 'carregado' : 'será criado'}\n`);
+
+    // Passo 4: Detectar domínio do projeto
+    console.log('🎯 Detectando domínio do projeto...');
+    const domainConfig = projectProfile ?
+        { name: projectProfile.domain, agents: [], description: projectProfile.customDomain || projectProfile.domain } :
+        detectDomain();
+    console.log(`  ✅ Domínio detectado: ${domainConfig.description || domainConfig.name}`);
+    console.log(`  📌 Agentes especializados: ${domainConfig.agents.join(', ') || 'nenhum'}\n`);
+
+    // Passo 5: Validar regras do usuário (MEMORY)
+    console.log('📜 Carregando regras do usuário (MEMORY)...');
+    console.log('  ✅ Regras globais carregadas');
+    console.log('  ✅ Regras gerais (6 passos + relatórios) carregadas\n');
+
+    // Passo 6: Resumo final
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('✅ CONTEXTO CARREGADO COM SUCESSO!');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+    console.log('📊 Resumo do Contexto:');
+    console.log(`  • Sistema de Design: ${designSystem ? '✅ Carregado' : '❌ Não encontrado'}`);
+    console.log(`  • Árvore de Símbolos: ${symbolsTree ? '✅ Carregada' : '❌ Não encontrada'}`);
+    console.log(`  • Histórico de Builds: ${buildHistory ? '✅ Carregado' : '❌ Não encontrado'}`);
+    console.log(`  • Regras de Agentes: ${agentRules ? '✅ Carregadas' : '❌ Não encontradas'}`);
+    console.log(`  • Build Atual: ${currentBuild ? '✅ Carregado' : 'ℹ️ Será criado'}`);
+    console.log(`  • Domínio: ${domainConfig.description || domainConfig.name}`);
+    if (projectProfile) {
+        console.log(`  • Perfil do Projeto: ✅ ${projectProfile.projectName}`);
+    }
+    console.log('');
+
+    console.log('🚀 Sistema pronto para implementar!\n');
+
+    return {
+        designSystem,
+        symbolsTree,
+        buildHistory,
+        agentRules,
+        currentBuild,
+        domainConfig,
+        timestamp: new Date().toISOString(),
+        projectProfile,
+    };
+}
+
+
+// Passo 1: Executar pré-verificações
+console.log('📋 Passo 1: Verificando estrutura do projeto...');
+const preCheckResult = await runPreChecks();
+
+if (!preCheckResult.success) {
+    console.warn('\n⚠️ Avisos encontrados:');
+    preCheckResult.issues.forEach((issue) => console.warn(`  ${issue}`));
+    console.log('');
+} else {
+    console.log('  ✅ Estrutura do projeto OK\n');
+}
+
+// Passo 2: Carregar documentação base
+console.log('📚 Passo 2: Carregando documentação base...');
+const designSystem = loadMarkdown(PATHS.designSystem);
+const symbolsTree = loadMarkdown(PATHS.symbolsTree);
+const buildHistory = loadMarkdown(PATHS.buildHistory);
+const agentRules = loadMarkdown(PATHS.agentRules);
+console.log('  ✅ Documentação carregada\n');
+
+// Passo 3: Carregar build atual 
+console.log('📦 Passo 3: Carregando build atual...');
+const currentBuild = loadCurrentBuild();
+console.log(`  ${currentBuild ? '✅' : 'ℹ️'} Build atual ${currentBuild ? 'carregado' : 'será criado'}\n`);
+
+// Passo 4: Detectar domínio do projeto
+console.log('🎯 Passo 4: Detectando domínio do projeto...');
+const domainConfig = detectDomain();
+console.log(`  ✅ Domínio detectado: ${domainConfig.description || domainConfig.name}`);
+console.log(`  📌 Agentes especializados: ${domainConfig.agents.join(', ') || 'nenhum'}\n`);
+
+// Passo 5: Validar regras do usuário (MEMORY)
+console.log('📜 Passo 5: Carregando regras do usuário (MEMORY)...');
+console.log('  ✅ Regras globais carregadas');
+console.log('  ✅ Regras gerais (6 passos + relatórios) carregadas\n');
+
+// Passo 6: Resumo final
+console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+console.log('✅ CONTEXTO CARREGADO COM SUCESSO!');
+console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+console.log('📊 Resumo do Contexto:');
+console.log(`  • Sistema de Design: ${designSystem ? '✅ Carregado' : '❌ Não encontrado'}`);
+console.log(`  • Árvore de Símbolos: ${symbolsTree ? '✅ Carregada' : '❌ Não encontrada'}`);
+console.log(`  • Histórico de Builds: ${buildHistory ? '✅ Carregado' : '❌ Não encontrado'}`);
+console.log(`  • Regras de Agentes: ${agentRules ? '✅ Carregadas' : '❌ Não encontradas'}`);
+console.log(`  • Build Atual: ${currentBuild ? '✅ Carregado' : 'ℹ️ Será criado'}`);
+console.log(`  • Domínio: ${domainConfig.description || domainConfig.name}`);
+console.log('');
+
+console.log('🚀 Sistema pronto para implementar!\n');
+
+return {
+    designSystem,
+    symbolsTree,
+    buildHistory,
+    agentRules,
+    currentBuild,
+    domainConfig,
+    timestamp: new Date().toISOString(),
+};
+}
+
+/**
+ * Valida se o contexto foi carregado antes de prosseguir
+ */
+export function validateContextLoaded(context: ProjectContext | null): boolean {
+    if (!context) {
+        console.error('❌ ERRO: Contexto não foi carregado!');
+        console.error('💡 Execute "inicie o contexto" antes de prosseguir.\n');
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * Exibe resumo do contexto atual
+ */
+export function printContextSummary(context: ProjectContext): void {
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('📋 RESUMO DO CONTEXTO ATUAL');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    console.log(`🕐 Carregado em: ${new Date(context.timestamp).toLocaleString('pt-BR')}`);
+    console.log(`🎯 Domínio: ${context.domainConfig.description || context.domainConfig.name}`);
+    console.log(`📦 Build: ${getCurrentBuildNumber()}`);
+    console.log('');
+}

package/.agents/core/agent-parallelizer.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Testes para AgentParallelizer
+ */
+
+import { AgentParallelizer } from './agent-parallelizer';
+import { AgentAssignment } from '../task-analyzer-agent';
+
+describe('AgentParallelizer', () => {
+    describe('groupAgents', () => {
+        test('deve agrupar agentes independentes no mesmo grupo', () => {
+            const agents: AgentAssignment[] = [
+                { agentName: 'security-agent', subtask: 'test', priority: 1, confidence: 0.9 },
+                { agentName: 'documentation-agent', subtask: 'test', priority: 2, confidence: 0.9 },
+                { agentName: 'cms-agent', subtask: 'test', priority: 3, confidence: 0.9 }
+            ];
+
+            const groups = AgentParallelizer.groupAgents(agents);
+
+            // Todos são independentes, devem estar no mesmo grupo
+            expect(groups.length).toBe(1);
+            expect(groups[0].length).toBe(3);
+        });
+
+        test('deve separar agentes com dependências em grupos diferentes', () => {
+            const agents: AgentAssignment[] = [
+                { agentName: 'architecture-agent', subtask: 'test', priority: 1, confidence: 0.9 },
+                { agentName: 'frontend-agent', subtask: 'test', priority: 2, confidence: 0.9 }
+            ];
+
+            const groups = AgentParallelizer.groupAgents(agents);
+
+            // frontend-agent depende de architecture-agent
+            expect(groups.length).toBe(2);
+            expect(groups[0][0].agentName).toBe('architecture-agent');
+            expect(groups[1][0].agentName).toBe('frontend-agent');
+        });
+
+        test('deve respeitar dependências complexas', () => {
+            const agents: AgentAssignment[] = [
+                { agentName: 'architecture-agent', subtask: 'test', priority: 1, confidence: 0.9 },
+                { agentName: 'frontend-agent', subtask: 'test', priority: 2, confidence: 0.9 },
+                { agentName: 'quality-agent', subtask: 'test', priority: 3, confidence: 0.9 },
+                { agentName: 'security-agent', subtask: 'test', priority: 4, confidence: 0.9 }
+            ];
+
+            const groups = AgentParallelizer.groupAgents(agents);
+
+            // architecture primeiro
+            // frontend e security em paralelo
+            // quality por último (depende de frontend e architecture)
+            expect(groups.length).toBeGreaterThanOrEqual(2);
+            expect(groups[0][0].agentName).toBe('architecture-agent');
+        });
+    });
+
+    describe('canRunInParallel', () => {
+        test('deve retornar true para agentes independentes', () => {
+            const result = AgentParallelizer.canRunInParallel('security-agent', 'documentation-agent');
+            expect(result).toBe(true);
+        });
+
+        test('deve retornar false se um depende do outro', () => {
+            const result = AgentParallelizer.canRunInParallel('frontend-agent', 'architecture-agent');
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('estimateTimeReduction', () => {
+        test('deve calcular redução de tempo corretamente', () => {
+            const agents: AgentAssignment[] = [
+                { agentName: 'security-agent', subtask: 'test', priority: 1, confidence: 0.9 },
+                { agentName: 'documentation-agent', subtask: 'test', priority: 2, confidence: 0.9 },
+                { agentName: 'cms-agent', subtask: 'test', priority: 3, confidence: 0.9 }
+            ];
+
+            const estimate = AgentParallelizer.estimateTimeReduction(agents);
+
+            expect(estimate.sequential).toBeGreaterThan(estimate.parallel);
+            expect(estimate.reduction).toBeGreaterThan(0);
+            expect(estimate.reduction).toBeLessThanOrEqual(100);
+        });
+
+        test('deve retornar 0% de redução para agente único', () => {
+            const agents: AgentAssignment[] = [
+                { agentName: 'security-agent', subtask: 'test', priority: 1, confidence: 0.9 }
+            ];
+
+            const estimate = AgentParallelizer.estimateTimeReduction(agents);
+
+            expect(estimate.sequential).toBe(estimate.parallel);
+            expect(estimate.reduction).toBe(0);
+        });
+    });
+});

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

@@ -0,0 +1,108 @@
+/**
+ * Agent Parallelization Utility
+ * 
+ * Identifica agentes independentes e os executa em paralelo
+ * para reduzir tempo total de execução
+ */
+
+import { AgentAssignment } from '../task-analyzer-agent';
+
+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)
+        };
+    }
+}