wegho-agentes 4.0.1 → 5.0.0

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

@@ -1,4 +1,4 @@
-import { BaseAgent, TaskContext, TaskResult } from './base-agent';
+import { BaseAgent, TaskContext, TaskResult } from './base-agent.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { glob } from 'glob';
@@ -111,6 +111,34 @@ export class InventoryAgent extends BaseAgent {
                 };
             }
 
+            if (taskDescription.includes('cleanup') || taskDescription.includes('limpeza') || taskDescription.includes('unused')) {
+                await this.scanProject(); // Garantir dados frescos
+                await this.analyzeUsage(); // Analisar uso
+                const unused = await this.findUnusedItems();
+
+                // Gerar relatório
+                const reportPath = path.join(this.projectRoot, 'docs', 'CLEANUP_REPORT.md');
+                const reportContent = this.generateCleanupReport(unused);
+
+                // Garantir diretório docs
+                const docsDir = path.join(this.projectRoot, 'docs');
+                try {
+                    await fs.mkdir(docsDir, { recursive: true });
+                } catch { }
+
+                await fs.writeFile(reportPath, reportContent);
+
+                return {
+                    success: true,
+                    details: `Análise de limpeza concluída. ${unused.length} itens potencialmente não utilizados.`,
+                    recommendations: [
+                        `Relatório salvo em: ${reportPath}`,
+                        `Revise os itens antes de excluir (Next.js pages/layouts são falsos positivos comuns se não detectados corretamente)`
+                    ],
+                    issues: unused.length > 0 ? unused.slice(0, 5).map(i => `Não utilizado: ${i.name} (${i.type}) - ${i.path}`) : undefined
+                };
+            }
+
             if (taskDescription.includes('check') || taskDescription.includes('verificar')) {
                 const itemName = this.extractItemName(taskDescription);
                 const check = await this.checkDuplication(itemName, 'component');
@@ -275,49 +303,56 @@ export class InventoryAgent extends BaseAgent {
      */
     private async scanComponents(): Promise<void> {
         const patterns = ['**/*.tsx', '**/*.jsx', '!node_modules/**', '!.next/**', '!.agents/**'];
-
         const files = await glob(patterns, { cwd: this.projectRoot });
 
         for (const file of files) {
             const fullPath = path.join(this.projectRoot, file);
-            const content = await fs.readFile(fullPath, 'utf-8');
-
-            // Detectar componentes exportados
-            const exportMatches = content.matchAll(/export\s+(?:default\s+)?(?:function|const|class)\s+(\w+)/g);
-
-            for (const match of exportMatches) {
-                const componentName = match[1];
-
-                // Extrair props
-                const propsMatch = content.match(new RegExp(`${componentName}.*?\\(\\s*{([^}]+)}`, 's'));
-                const props = propsMatch
-                    ? propsMatch[1]
-                        .split(',')
-                        .map((p) => p.trim().split(':')[0].trim())
-                        .filter(Boolean)
-                    : [];
-
-                // Extrair imports (dependências)
-                const importMatches = content.matchAll(/import\s+.*?from\s+['"]([^'"]+)['"]/g);
-                const dependencies = Array.from(importMatches, (m) => m[1]);
-
-                const component: Component = {
-                    id: `component:${file}:${componentName}`,
-                    name: componentName,
-                    type: 'component',
-                    path: file,
-                    exports: [componentName],
-                    props,
-                    dependencies,
-                    metadata: {
-                        isDefaultExport: content.includes(`export default ${componentName}`),
-                    },
-                    usedBy: [], // Será preenchido em scan futuro
-                    createdAt: new Date().toISOString(),
-                    lastModified: new Date().toISOString(),
-                };
 
-                this.inventory.set(component.id, component);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.isDirectory()) continue;
+
+                const content = await fs.readFile(fullPath, 'utf-8');
+
+                // Detectar componentes exportados
+                const exportMatches = content.matchAll(/export\s+(?:default\s+)?(?:function|const|class)\s+(\w+)/g);
+
+                for (const match of exportMatches) {
+                    const componentName = match[1];
+
+                    // Extrair props
+                    const propsMatch = content.match(new RegExp(`${componentName}.*?\\(\\s*{([^}]+)}`, 's'));
+                    const props = propsMatch
+                        ? propsMatch[1]
+                            .split(',')
+                            .map((p) => p.trim().split(':')[0].trim())
+                            .filter(Boolean)
+                        : [];
+
+                    // Extrair imports (dependências)
+                    const importMatches = content.matchAll(/import\s+.*?from\s+['"]([^'"]+)['"]/g);
+                    const dependencies = Array.from(importMatches, (m) => m[1]);
+
+                    const component: Component = {
+                        id: `component:${file}:${componentName}`,
+                        name: componentName,
+                        type: 'component',
+                        path: file,
+                        exports: [componentName],
+                        props,
+                        dependencies,
+                        metadata: {
+                            isDefaultExport: content.includes(`export default ${componentName}`),
+                        },
+                        usedBy: [],
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                    };
+
+                    this.inventory.set(component.id, component);
+                }
+            } catch (err) {
+                console.warn(`[inventory-agent] Erro ao ler componente ${file}: ${(err as Error).message}`);
             }
         }
     }
@@ -327,34 +362,41 @@ export class InventoryAgent extends BaseAgent {
      */
     private async scanVariables(): Promise<void> {
         const patterns = ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '!node_modules/**', '!.next/**'];
-
         const files = await glob(patterns, { cwd: this.projectRoot });
 
         for (const file of files) {
             const fullPath = path.join(this.projectRoot, file);
-            const content = await fs.readFile(fullPath, 'utf-8');
-
-            // Detectar variáveis exportadas
-            const varMatches = content.matchAll(/export\s+const\s+(\w+)\s*[:=]\s*(.+?)(?:[;\n])/g);
-
-            for (const match of varMatches) {
-                const [, varName, value] = match;
-
-                const variable: Variable = {
-                    id: `variable:${file}:${varName}`,
-                    name: varName,
-                    type: 'variable',
-                    path: file,
-                    scope: 'exported',
-                    value: value.trim(),
-                    dataType: this.inferType(value),
-                    metadata: {},
-                    usedBy: [],
-                    createdAt: new Date().toISOString(),
-                    lastModified: new Date().toISOString(),
-                };
 
-                this.inventory.set(variable.id, variable);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.isDirectory()) continue;
+
+                const content = await fs.readFile(fullPath, 'utf-8');
+
+                // Detectar variáveis exportadas
+                const varMatches = content.matchAll(/export\s+const\s+(\w+)\s*[:=]\s*(.+?)(?:[;\n])/g);
+
+                for (const match of varMatches) {
+                    const [, varName, value] = match;
+
+                    const variable: Variable = {
+                        id: `variable:${file}:${varName}`,
+                        name: varName,
+                        type: 'variable',
+                        path: file,
+                        scope: 'exported',
+                        value: value.trim(),
+                        dataType: this.inferType(value),
+                        metadata: {},
+                        usedBy: [],
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                    };
+
+                    this.inventory.set(variable.id, variable);
+                }
+            } catch (err) {
+                console.warn(`[inventory-agent] Erro ao ler variável ${file}: ${(err as Error).message}`);
             }
         }
     }
@@ -364,34 +406,41 @@ export class InventoryAgent extends BaseAgent {
      */
     private async scanEndpoints(): Promise<void> {
         const patterns = ['**/api/**/*.ts', '**/api/**/*.js', '!node_modules/**'];
-
         const files = await glob(patterns, { cwd: this.projectRoot });
 
         for (const file of files) {
             const fullPath = path.join(this.projectRoot, file);
-            const content = await fs.readFile(fullPath, 'utf-8');
-
-            // Detectar métodos HTTP
-            const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] as const;
-
-            for (const method of methods) {
-                const regex = new RegExp(`export\\s+async\\s+function\\s+${method}`, 'g');
-                if (regex.test(content)) {
-                    const endpoint: Endpoint = {
-                        id: `endpoint:${file}:${method}`,
-                        name: file.replace(/.*\/api\//, '/api/').replace(/\/route\.(ts|js)/, ''),
-                        type: 'endpoint',
-                        path: file,
-                        method,
-                        authentication: content.includes('auth') || content.includes('session'),
-                        metadata: {},
-                        usedBy: [],
-                        createdAt: new Date().toISOString(),
-                        lastModified: new Date().toISOString(),
-                    };
 
-                    this.inventory.set(endpoint.id, endpoint);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.isDirectory()) continue;
+
+                const content = await fs.readFile(fullPath, 'utf-8');
+
+                // Detectar métodos HTTP
+                const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] as const;
+
+                for (const method of methods) {
+                    const regex = new RegExp(`export\\s+async\\s+function\\s+${method}`, 'g');
+                    if (regex.test(content)) {
+                        const endpoint: Endpoint = {
+                            id: `endpoint:${file}:${method}`,
+                            name: file.replace(/.*\/api\//, '/api/').replace(/\/route\.(ts|js)/, ''),
+                            type: 'endpoint',
+                            path: file,
+                            method,
+                            authentication: content.includes('auth') || content.includes('session'),
+                            metadata: {},
+                            usedBy: [],
+                            createdAt: new Date().toISOString(),
+                            lastModified: new Date().toISOString(),
+                        };
+
+                        this.inventory.set(endpoint.id, endpoint);
+                    }
                 }
+            } catch (err) {
+                console.warn(`[inventory-agent] Erro ao ler endpoint ${file}: ${(err as Error).message}`);
             }
         }
     }
@@ -401,34 +450,41 @@ export class InventoryAgent extends BaseAgent {
      */
     private async scanTypes(): Promise<void> {
         const patterns = ['**/types/**/*.ts', '**/*.d.ts', '!node_modules/**'];
-
         const files = await glob(patterns, { cwd: this.projectRoot });
 
         for (const file of files) {
             const fullPath = path.join(this.projectRoot, file);
-            const content = await fs.readFile(fullPath, 'utf-8');
-
-            // Detectar interfaces e types
-            const typeMatches = content.matchAll(/(?:export\s+)?(?:interface|type)\s+(\w+)/g);
-
-            for (const match of typeMatches) {
-                const typeName = match[1];
-
-                const typeItem: InventoryItem = {
-                    id: `type:${file}:${typeName}`,
-                    name: typeName,
-                    type: 'type',
-                    path: file,
-                    metadata: {
-                        isInterface: content.includes(`interface ${typeName}`),
-                        isType: content.includes(`type ${typeName}`),
-                    },
-                    usedBy: [],
-                    createdAt: new Date().toISOString(),
-                    lastModified: new Date().toISOString(),
-                };
 
-                this.inventory.set(typeItem.id, typeItem);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.isDirectory()) continue;
+
+                const content = await fs.readFile(fullPath, 'utf-8');
+
+                // Detectar interfaces e types
+                const typeMatches = content.matchAll(/(?:export\s+)?(?:interface|type)\s+(\w+)/g);
+
+                for (const match of typeMatches) {
+                    const typeName = match[1];
+
+                    const typeItem: InventoryItem = {
+                        id: `type:${file}:${typeName}`,
+                        name: typeName,
+                        type: 'type',
+                        path: file,
+                        metadata: {
+                            isInterface: content.includes(`interface ${typeName}`),
+                            isType: content.includes(`type ${typeName}`),
+                        },
+                        usedBy: [],
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                    };
+
+                    this.inventory.set(typeItem.id, typeItem);
+                }
+            } catch (err) {
+                console.warn(`[inventory-agent] Erro ao ler tipo ${file}: ${(err as Error).message}`);
             }
         }
     }
@@ -437,36 +493,42 @@ export class InventoryAgent extends BaseAgent {
      * Escaneia schema do banco de dados (Supabase/PostgreSQL)
      */
     private async scanDatabase(): Promise<void> {
-        // Procurar por arquivos de schema ou migrations
         const patterns = ['**/supabase/migrations/**/*.sql', '**/prisma/schema.prisma', '!node_modules/**'];
-
         const files = await glob(patterns, { cwd: this.projectRoot });
 
         for (const file of files) {
             const fullPath = path.join(this.projectRoot, file);
-            const content = await fs.readFile(fullPath, 'utf-8');
-
-            // Detectar CREATE TABLE
-            const tableMatches = content.matchAll(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s*\(/gi);
-
-            for (const match of tableMatches) {
-                const tableName = match[1];
-
-                const table: DatabaseTable = {
-                    id: `table:${tableName}`,
-                    name: tableName,
-                    type: 'table',
-                    path: file,
-                    schema: 'public',
-                    columns: [], // Seria necessário parser SQL completo
-                    relationships: [],
-                    metadata: {},
-                    usedBy: [],
-                    createdAt: new Date().toISOString(),
-                    lastModified: new Date().toISOString(),
-                };
 
-                this.inventory.set(table.id, table);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (stat.isDirectory()) continue;
+
+                const content = await fs.readFile(fullPath, 'utf-8');
+
+                // Detectar CREATE TABLE
+                const tableMatches = content.matchAll(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s*\(/gi);
+
+                for (const match of tableMatches) {
+                    const tableName = match[1];
+
+                    const table: DatabaseTable = {
+                        id: `table:${tableName}`,
+                        name: tableName,
+                        type: 'table',
+                        path: file,
+                        schema: 'public',
+                        columns: [],
+                        relationships: [],
+                        metadata: {},
+                        usedBy: [],
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                    };
+
+                    this.inventory.set(table.id, table);
+                }
+            } catch (err) {
+                console.warn(`[inventory-agent] Erro ao ler schema ${file}: ${(err as Error).message}`);
             }
         }
     }
@@ -521,13 +583,11 @@ export class InventoryAgent extends BaseAgent {
                 .catch(() => false);
 
             if (!indexExists) {
-                // Inventário vazio, fazer scan inicial
                 await this.scanProject();
                 return;
             }
 
             this.inventory.clear();
-
             const types = ['component', 'variable', 'table', 'endpoint', 'type'];
 
             for (const type of types) {
@@ -579,4 +639,119 @@ export class InventoryAgent extends BaseAgent {
         const match = description.match(/["']([^"']+)["']/);
         return match ? match[1] : '';
     }
+
+    // ============================================================
+    // 🧹 LIMPEZA E ANÁLISE DE USO (OTIMIZADO)
+    // ============================================================
+
+    /**
+     * Analisa o uso de cada item no projeto - OTIMIZADO
+     */
+    async analyzeUsage(): Promise<void> {
+        console.log('🕵️ [inventory-agent] Analisando referências cruzadas (Modo Otimizado)...');
+
+        await this.loadInventory();
+        const items = Array.from(this.inventory.values());
+
+        // Resetar contadores
+        items.forEach(i => i.usedBy = []);
+
+        const patterns = ['**/*.tsx', '**/*.jsx', '**/*.ts', '**/*.js', '!node_modules/**', '!.next/**', '!.agents/**'];
+        const files = await glob(patterns, { cwd: this.projectRoot });
+
+        // Mapa para busca rápida de itens por nome
+        // Tratando colisão de nomes: Map<Name, Item[]>
+        const itemsByName = new Map<string, InventoryItem[]>();
+        for (const item of items) {
+            if (!itemsByName.has(item.name)) {
+                itemsByName.set(item.name, []);
+            }
+            itemsByName.get(item.name)!.push(item);
+        }
+
+        let processedFiles = 0;
+
+        for (const file of files) {
+            const fullPath = path.join(this.projectRoot, file);
+            try {
+                const content = await fs.readFile(fullPath, 'utf-8');
+
+                // Extrair todos os "tokens" (palavras) do arquivo
+                // Isso é muito mais rápido que rodar milhares de regex
+                const tokens = new Set(content.match(/\b\w+\b/g) || []);
+
+                // Verificar quais itens estão presentes nos tokens
+                for (const [name, potentialItems] of itemsByName) {
+                    if (tokens.has(name)) {
+                        for (const item of potentialItems) {
+                            // Evitar auto-referência (arquivo definindo o item)
+                            // Apenas se o path for exatamente o mesmo
+                            if (item.path !== file) {
+                                item.usedBy.push(file);
+                            }
+                        }
+                    }
+                }
+
+                processedFiles++;
+            } catch (err) {
+                console.warn(`Erro ao ler arquivo ${file}: ${(err as Error).message}`);
+            }
+        }
+
+        // Salvar inventário atualizado com contagem de uso
+        await this.saveInventory();
+        console.log(`✅ [inventory-agent] Análise completa. ${files.length} arquivos processados.`);
+    }
+
+    /**
+     * Encontra itens não utilizados (com whitelist)
+     */
+    async findUnusedItems(): Promise<InventoryItem[]> {
+        await this.loadInventory();
+        const items = Array.from(this.inventory.values());
+
+        return items.filter(item => {
+            // Filtrar quem tem uso
+            if (item.usedBy.length > 0) return false;
+
+            // Whitelists (Falsos positivos conhecidos)
+
+            // 1. Next.js Pages/Layouts/API Routes (Sempre usados pelo framework)
+            if (item.path.includes('page.tsx') || item.path.includes('layout.tsx') || item.path.includes('route.ts')) return false;
+
+            // 2. Config files
+            if (item.name.includes('Config') || item.path.includes('config')) return false;
+
+            // 3. Types (muitas vezes importados globalmente ou d.ts)
+            if (item.type === 'type' && item.path.endsWith('.d.ts')) return false;
+
+            return true;
+        });
+    }
+
+    private generateCleanupReport(unused: InventoryItem[]): string {
+        let report = '# 🧹 Relatório de Limpeza de Código\n\n';
+        report += `**Data**: ${new Date().toLocaleDateString()}\n`;
+        report += `**Total de Itens Analisados**: ${this.inventory.size}\n`;
+        report += `**Potencialmente Não Utilizados**: ${unused.length}\n\n`;
+
+        report += '> ⚠️ **Atenção**: Esta análise busca referências textuais exatas. Valide manualmente antes de excluir, pois podem haver usos dinâmicos ou indiretos.\n\n';
+
+        const byType = new Map<string, InventoryItem[]>();
+        unused.forEach(i => {
+            if (!byType.has(i.type)) byType.set(i.type, []);
+            byType.get(i.type)!.push(i);
+        });
+
+        for (const [type, items] of byType) {
+            report += `## ${type.toUpperCase()} (${items.length})\n`;
+            items.forEach(i => {
+                report += `- **${i.name}**\n  - Path: \`${i.path}\`\n  - Last Modified: ${new Date(i.lastModified).toLocaleDateString()}\n`;
+            });
+            report += '\n';
+        }
+
+        return report;
+    }
 }

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

@@ -11,7 +11,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { CacheManager } from './cache-manager';
+import { CacheManager } from './cache-manager.js';
 
 /**
  * Entrada individual de memória

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

@@ -0,0 +1,113 @@
+import { BaseAgent, TaskContext, TaskResult } from './base-agent.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * NextJS Agent - Especialista em Next.js e React
+ * 
+ * Responsabilidades:
+ * - Desenvolvimento de aplicações Next.js (App Router, Server Components)
+ * - Otimização de performance e SEO
+ * - Server Actions e API Routes
+ * - Integração com Vercel
+ * 
+ * Skills: nextjs-best-practices, react-best-practices, vercel-deployment,
+ *         web-performance-optimization, react-patterns
+ */
+
+export class NextJSAgent extends BaseAgent {
+    private skillsPath: string;
+
+    constructor(memoryPath: string) {
+        super('nextjs-agent', memoryPath);
+        this.skillsPath = path.join(process.cwd(), 'skills');
+    }
+
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        console.log(`\n🚀 NextJS Agent analisando tarefa...\n`);
+
+        const issues: string[] = [];
+        const recommendations: string[] = [];
+
+        // Carregar skills relevantes
+        const skills = this.loadRelevantSkills([
+            'nextjs-best-practices',
+            'react-best-practices',
+            'react-patterns',
+            'vercel-deployment',
+            'web-performance-optimization'
+        ]);
+
+        // Análise de Next.js
+        if (taskDescription.toLowerCase().includes('nextjs') ||
+            taskDescription.toLowerCase().includes('next.js')) {
+
+            recommendations.push('✅ Usar App Router para novas features');
+            recommendations.push('✅ Implementar Server Components quando possível');
+            recommendations.push('✅ Usar Server Actions para mutations');
+            recommendations.push('✅ Otimizar imagens com next/image');
+            recommendations.push('✅ Implementar metadata para SEO');
+        }
+
+        // Análise de React
+        if (taskDescription.toLowerCase().includes('component')) {
+            recommendations.push('✅ Usar TypeScript para type safety');
+            recommendations.push('✅ Implementar error boundaries');
+            recommendations.push('✅ Usar React.memo para otimização');
+            recommendations.push('✅ Seguir padrões de composição');
+        }
+
+        // Análise de Performance
+        if (taskDescription.toLowerCase().includes('performance') ||
+            taskDescription.toLowerCase().includes('otimização')) {
+
+            recommendations.push('✅ Implementar code splitting');
+            recommendations.push('✅ Usar dynamic imports');
+            recommendations.push('✅ Otimizar bundle size');
+            recommendations.push('✅ Implementar caching strategies');
+        }
+
+        // Análise de Deploy
+        if (taskDescription.toLowerCase().includes('deploy') ||
+            taskDescription.toLowerCase().includes('vercel')) {
+
+            recommendations.push('✅ Configurar variáveis de ambiente');
+            recommendations.push('✅ Implementar preview deployments');
+            recommendations.push('✅ Configurar edge functions se necessário');
+        }
+
+        const success = issues.length === 0;
+
+        return {
+            success,
+            details: success
+                ? `NextJS Agent: ${recommendations.length} recomendações geradas`
+                : `NextJS Agent: ${issues.length} problemas encontrados`,
+            recommendations,
+            issues,
+            blockers: issues
+        };
+    }
+
+    /**
+     * Carrega skills relevantes do diretório skills/
+     */
+    private loadRelevantSkills(skillNames: string[]): Map<string, string> {
+        const skills = new Map<string, string>();
+
+        for (const skillName of skillNames) {
+            const skillPath = path.join(this.skillsPath, skillName, 'SKILL.md');
+
+            try {
+                if (fs.existsSync(skillPath)) {
+                    const content = fs.readFileSync(skillPath, 'utf-8');
+                    skills.set(skillName, content);
+                }
+            } catch (error) {
+                // Skill não encontrada, continuar
+            }
+        }
+
+        return skills;
+    }
+}