wegho-agentes 4.0.1

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

@@ -0,0 +1,582 @@
+import { BaseAgent, TaskContext, TaskResult } from './base-agent';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { glob } from 'glob';
+
+// ============================================================
+// 🏭 INVENTORY AGENT - ALMOXARIFADO CENTRAL DO SISTEMA
+// ============================================================
+// Responsável por:
+// 1. Mapear TUDO no projeto (componentes, variáveis, banco, APIs)
+// 2. Fornecer busca rápida para outros agentes
+// 3. IMPEDIR duplicação de código
+// 4. Organizar e catalogar recursos
+// ============================================================
+
+interface InventoryItem {
+    id: string;
+    name: string;
+    type: 'component' | 'variable' | 'table' | 'endpoint' | 'type' | 'asset' | 'function';
+    path: string;
+    line?: number;
+    metadata: Record<string, any>;
+    usedBy: string[];
+    createdAt: string;
+    lastModified: string;
+}
+
+interface Component extends InventoryItem {
+    type: 'component';
+    exports: string[];
+    props: string[];
+    dependencies: string[];
+}
+
+interface Variable extends InventoryItem {
+    type: 'variable';
+    scope: 'global' | 'local' | 'exported';
+    value?: string;
+    dataType: string;
+}
+
+interface DatabaseTable extends InventoryItem {
+    type: 'table';
+    schema: string;
+    columns: Array<{
+        name: string;
+        type: string;
+        nullable: boolean;
+        primaryKey?: boolean;
+        foreignKey?: string;
+    }>;
+    relationships: Array<{
+        table: string;
+        type: 'one-to-one' | 'one-to-many' | 'many-to-many';
+        foreignKey: string;
+    }>;
+}
+
+interface Endpoint extends InventoryItem {
+    type: 'endpoint';
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    params?: string[];
+    body?: Record<string, string>;
+    response?: string;
+    authentication: boolean;
+}
+
+interface InventoryQuery {
+    type?: InventoryItem['type'];
+    name?: string;
+    path?: string;
+    fuzzy?: boolean;
+}
+
+interface DuplicationCheck {
+    exists: boolean;
+    duplicates: InventoryItem[];
+    suggestions: string[];
+}
+
+export class InventoryAgent extends BaseAgent {
+    private inventory: Map<string, InventoryItem> = new Map();
+    private inventoryPath: string;
+    private projectRoot: string;
+
+    constructor(projectRoot: string, memoryBasePath: string = '.agents/memory') {
+        super('inventory-agent', memoryBasePath);
+        this.projectRoot = projectRoot;
+        this.inventoryPath = path.join(memoryBasePath, 'inventory-agent', 'inventory');
+    }
+
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        try {
+            // Determinar ação baseada na descrição da tarefa
+            if (taskDescription.includes('scan') || taskDescription.includes('escanear')) {
+                await this.scanProject();
+                return {
+                    success: true,
+                    details: `Inventário completo: ${this.inventory.size} itens catalogados`,
+                    recommendations: [`Total de ${this.inventory.size} itens no almoxarifado`],
+                };
+            }
+
+            if (taskDescription.includes('find') || taskDescription.includes('buscar')) {
+                const query = this.parseQuery(taskDescription);
+                const results = await this.findAll(query);
+                return {
+                    success: true,
+                    details: `Encontrados ${results.length} itens`,
+                    recommendations: results.map((r) => `${r.type}: ${r.name} (${r.path})`),
+                };
+            }
+
+            if (taskDescription.includes('check') || taskDescription.includes('verificar')) {
+                const itemName = this.extractItemName(taskDescription);
+                const check = await this.checkDuplication(itemName, 'component');
+                return {
+                    success: !check.exists,
+                    details: check.exists
+                        ? `Item "${itemName}" já existe`
+                        : `Nenhuma duplicação encontrada para "${itemName}"`,
+                    warnings: check.exists ? [`Duplicação detectada: ${itemName}`] : undefined,
+                    recommendations: check.suggestions,
+                };
+            }
+
+            // Scan padrão
+            await this.scanProject();
+            return {
+                success: true,
+                details: `Scan completo: ${this.inventory.size} itens catalogados`,
+            };
+        } catch (error) {
+            return {
+                success: false,
+                details: `Erro ao executar tarefa: ${(error as Error).message}`,
+                issues: [(error as Error).message],
+            };
+        }
+    }
+
+    // ============================================================
+    // 🔍 MÉTODOS DE BUSCA (Para outros agentes)
+    // ============================================================
+
+    /**
+     * Busca um único item no inventário
+     */
+    async find(query: InventoryQuery): Promise<InventoryItem | null> {
+        const results = await this.findAll(query);
+        return results[0] || null;
+    }
+
+    /**
+     * Busca todos os itens que correspondem à query
+     */
+    async findAll(query: InventoryQuery): Promise<InventoryItem[]> {
+        await this.loadInventory();
+
+        let results = Array.from(this.inventory.values());
+
+        // Filtrar por tipo
+        if (query.type) {
+            results = results.filter((item) => item.type === query.type);
+        }
+
+        // Filtrar por nome
+        if (query.name) {
+            if (query.fuzzy) {
+                // Busca fuzzy (case-insensitive, parcial)
+                const searchTerm = query.name.toLowerCase();
+                results = results.filter((item) => item.name.toLowerCase().includes(searchTerm));
+            } else {
+                // Busca exata
+                results = results.filter((item) => item.name === query.name);
+            }
+        }
+
+        // Filtrar por path
+        if (query.path) {
+            results = results.filter((item) => item.path.includes(query.path!));
+        }
+
+        return results;
+    }
+
+    /**
+     * Busca textual em todo o inventário
+     */
+    async search(text: string): Promise<InventoryItem[]> {
+        await this.loadInventory();
+
+        const searchTerm = text.toLowerCase();
+        return Array.from(this.inventory.values()).filter(
+            (item) =>
+                item.name.toLowerCase().includes(searchTerm) ||
+                item.path.toLowerCase().includes(searchTerm) ||
+                JSON.stringify(item.metadata).toLowerCase().includes(searchTerm)
+        );
+    }
+
+    // ============================================================
+    // 🛡️ VERIFICAÇÃO ANTI-DUPLICAÇÃO (CRÍTICO!)
+    // ============================================================
+
+    /**
+     * Verifica se um item já existe antes de criar
+     * TODOS os agentes DEVEM chamar isso antes de criar algo novo!
+     */
+    async checkDuplication(name: string, type: InventoryItem['type']): Promise<DuplicationCheck> {
+        await this.loadInventory();
+
+        // Busca exata
+        const exact = await this.find({ name, type });
+
+        // Busca fuzzy (similares)
+        const similar = await this.findAll({ name, type, fuzzy: true });
+
+        const exists = exact !== null;
+        const duplicates = similar.filter((item) => item.name !== name);
+
+        const suggestions: string[] = [];
+
+        if (exists) {
+            suggestions.push(`⚠️ Item "${name}" já existe em: ${exact.path}`);
+            suggestions.push(`💡 Use o existente em vez de criar novo`);
+        }
+
+        if (duplicates.length > 0) {
+            suggestions.push(`⚠️ Encontrados ${duplicates.length} item(ns) similar(es):`);
+            duplicates.forEach((dup) => {
+                suggestions.push(`   - ${dup.name} (${dup.path})`);
+            });
+            suggestions.push(`💡 Considere reutilizar um desses em vez de criar novo`);
+        }
+
+        if (!exists && duplicates.length === 0) {
+            suggestions.push(`✅ Nenhuma duplicação encontrada. Seguro criar "${name}"`);
+        }
+
+        return {
+            exists,
+            duplicates,
+            suggestions,
+        };
+    }
+
+    // ============================================================
+    // 📊 MÉTODOS DE SCAN
+    // ============================================================
+
+    /**
+     * Escaneia o projeto inteiro e atualiza o inventário
+     */
+    async scanProject(): Promise<void> {
+        console.log('🔍 [inventory-agent] Escaneando projeto...');
+
+        this.inventory.clear();
+
+        await Promise.all([
+            this.scanComponents(),
+            this.scanVariables(),
+            this.scanEndpoints(),
+            this.scanTypes(),
+            this.scanDatabase(),
+        ]);
+
+        await this.saveInventory();
+
+        console.log(`✅ [inventory-agent] Scan completo: ${this.inventory.size} itens catalogados`);
+    }
+
+    /**
+     * Escaneia componentes React/Next.js
+     */
+    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);
+            }
+        }
+    }
+
+    /**
+     * Escaneia variáveis globais e exportadas
+     */
+    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);
+            }
+        }
+    }
+
+    /**
+     * Escaneia endpoints de API
+     */
+    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);
+                }
+            }
+        }
+    }
+
+    /**
+     * Escaneia tipos TypeScript
+     */
+    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);
+            }
+        }
+    }
+
+    /**
+     * 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);
+            }
+        }
+    }
+
+    // ============================================================
+    // 💾 PERSISTÊNCIA
+    // ============================================================
+
+    /**
+     * Salva inventário em arquivos JSON
+     */
+    private async saveInventory(): Promise<void> {
+        await fs.mkdir(this.inventoryPath, { recursive: true });
+
+        // Agrupar por tipo
+        const byType = new Map<string, InventoryItem[]>();
+
+        for (const item of this.inventory.values()) {
+            if (!byType.has(item.type)) {
+                byType.set(item.type, []);
+            }
+            byType.get(item.type)!.push(item);
+        }
+
+        // Salvar cada tipo em arquivo separado
+        for (const [type, items] of byType) {
+            const filePath = path.join(this.inventoryPath, `${type}s.json`);
+            await fs.writeFile(filePath, JSON.stringify(items, null, 2));
+        }
+
+        // Salvar índice geral
+        const index = {
+            totalItems: this.inventory.size,
+            byType: Object.fromEntries(
+                Array.from(byType.entries()).map(([type, items]) => [type, items.length])
+            ),
+            lastUpdated: new Date().toISOString(),
+        };
+
+        await fs.writeFile(path.join(this.inventoryPath, 'index.json'), JSON.stringify(index, null, 2));
+    }
+
+    /**
+     * Carrega inventário dos arquivos JSON
+     */
+    private async loadInventory(): Promise<void> {
+        try {
+            const indexPath = path.join(this.inventoryPath, 'index.json');
+            const indexExists = await fs
+                .access(indexPath)
+                .then(() => true)
+                .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) {
+                const filePath = path.join(this.inventoryPath, `${type}s.json`);
+                const fileExists = await fs
+                    .access(filePath)
+                    .then(() => true)
+                    .catch(() => false);
+
+                if (fileExists) {
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const items = JSON.parse(content) as InventoryItem[];
+
+                    for (const item of items) {
+                        this.inventory.set(item.id, item);
+                    }
+                }
+            }
+        } catch (error) {
+            console.warn('[inventory-agent] Erro ao carregar inventário:', error);
+        }
+    }
+
+    // ============================================================
+    // 🛠️ UTILITÁRIOS
+    // ============================================================
+
+    private inferType(value: string): string {
+        if (value.startsWith("'") || value.startsWith('"') || value.startsWith('`')) return 'string';
+        if (value === 'true' || value === 'false') return 'boolean';
+        if (!isNaN(Number(value))) return 'number';
+        if (value.startsWith('[')) return 'array';
+        if (value.startsWith('{')) return 'object';
+        return 'unknown';
+    }
+
+    private parseQuery(description: string): InventoryQuery {
+        const query: InventoryQuery = { fuzzy: true };
+
+        if (description.includes('component')) query.type = 'component';
+        if (description.includes('variable')) query.type = 'variable';
+        if (description.includes('endpoint')) query.type = 'endpoint';
+        if (description.includes('table')) query.type = 'table';
+
+        return query;
+    }
+
+    private extractItemName(description: string): string {
+        const match = description.match(/["']([^"']+)["']/);
+        return match ? match[1] : '';
+    }
+}