wegho-agentes 7.0.0 → 7.0.1

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

@@ -1,397 +0,0 @@
-/**
- * Memory System - Sistema de Memória para Agentes
- * 
- * Responsabilidades:
- * - Gerenciar memória persistente de cada agente
- * - Registrar sucessos e falhas
- * - Armazenar aprendizados
- * - Buscar casos similares
- * - Fornecer recomendações baseadas em histórico
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { CacheManager } from './cache-manager.js';
-
-/**
- * Entrada individual de memória
- */
-export interface MemoryEntry {
-    id: string;
-    timestamp: Date;
-    taskDescription: string;
-    context: {
-        files: string[];
-        areas: string[];
-        complexity: 'low' | 'medium' | 'high';
-    };
-    result: 'success' | 'failure';
-    details: string;
-    userFeedback?: {
-        satisfied: boolean;
-        likes: string[];
-        dislikes: string[];
-        suggestions: string[];
-    };
-    metadata?: Record<string, any>;
-}
-
-/**
- * Padrão aprendido
- */
-export interface Learning {
-    id: string;
-    pattern: string;
-    description: string;
-    recommendation: string;
-    confidence: number; // 0-1
-    occurrences: number;
-    lastSeen: Date;
-    examples: string[]; // IDs de MemoryEntry
-}
-
-/**
- * Estrutura de memória de um agente
- */
-export interface AgentMemory {
-    agentName: string;
-    successes: MemoryEntry[];
-    failures: MemoryEntry[];
-    learnings: Learning[];
-    stats: {
-        totalTasks: number;
-        successRate: number;
-        lastUpdated: Date;
-    };
-}
-
-/**
- * Sistema de Memória
- */
-export class MemorySystem {
-    private memoryBasePath: string;
-    private maxEntries: number;
-    private cache: CacheManager;
-
-    constructor(memoryBasePath: string = '.agents/memory', maxEntries: number = 1000) {
-        this.memoryBasePath = memoryBasePath;
-        this.maxEntries = maxEntries;
-        this.cache = new CacheManager(300000, 500); // 5 min TTL, max 500 entries
-        this.ensureMemoryStructure();
-    }
-
-    /**
-     * Garante que a estrutura de pastas existe
-     */
-    private ensureMemoryStructure(): void {
-        if (!fs.existsSync(this.memoryBasePath)) {
-            fs.mkdirSync(this.memoryBasePath, { recursive: true });
-        }
-    }
-
-    /**
-     * Garante que a pasta do agente existe
-     */
-    private ensureAgentFolder(agentName: string): string {
-        const agentPath = path.join(this.memoryBasePath, agentName);
-        if (!fs.existsSync(agentPath)) {
-            fs.mkdirSync(agentPath, { recursive: true });
-        }
-        return agentPath;
-    }
-
-    /**
-     * Carrega memória de um agente
-     */
-    loadMemory(agentName: string): AgentMemory {
-        const agentPath = this.ensureAgentFolder(agentName);
-
-        const successesPath = path.join(agentPath, 'successes.json');
-        const failuresPath = path.join(agentPath, 'failures.json');
-        const learningsPath = path.join(agentPath, 'learnings.json');
-
-        const successes = this.loadJsonFile<MemoryEntry[]>(successesPath, []);
-        const failures = this.loadJsonFile<MemoryEntry[]>(failuresPath, []);
-        const learnings = this.loadJsonFile<Learning[]>(learningsPath, []);
-
-        const totalTasks = successes.length + failures.length;
-        const successRate = totalTasks > 0 ? successes.length / totalTasks : 0;
-
-        return {
-            agentName,
-            successes,
-            failures,
-            learnings,
-            stats: {
-                totalTasks,
-                successRate,
-                lastUpdated: new Date(),
-            },
-        };
-    }
-
-    /**
-     * Salva memória de um agente
-     */
-    saveMemory(memory: AgentMemory): void {
-        const agentPath = this.ensureAgentFolder(memory.agentName);
-
-        // Limitar número de entradas
-        const successes = this.limitEntries(memory.successes);
-        const failures = this.limitEntries(memory.failures);
-
-        this.saveJsonFile(path.join(agentPath, 'successes.json'), successes);
-        this.saveJsonFile(path.join(agentPath, 'failures.json'), failures);
-        this.saveJsonFile(path.join(agentPath, 'learnings.json'), memory.learnings);
-    }
-
-    /**
-     * Registra um sucesso
-     */
-    recordSuccess(
-        agentName: string,
-        taskDescription: string,
-        context: MemoryEntry['context'],
-        details: string,
-        userFeedback?: MemoryEntry['userFeedback']
-    ): void {
-        const memory = this.loadMemory(agentName);
-
-        const entry: MemoryEntry = {
-            id: this.generateId(),
-            timestamp: new Date(),
-            taskDescription,
-            context,
-            result: 'success',
-            details,
-            userFeedback,
-        };
-
-        memory.successes.push(entry);
-        this.saveMemory(memory);
-
-        console.log(`✅ [${agentName}] Sucesso registrado: ${taskDescription}`);
-    }
-
-    /**
-     * Registra uma falha
-     */
-    recordFailure(
-        agentName: string,
-        taskDescription: string,
-        context: MemoryEntry['context'],
-        details: string,
-        userFeedback?: MemoryEntry['userFeedback']
-    ): void {
-        const memory = this.loadMemory(agentName);
-
-        const entry: MemoryEntry = {
-            id: this.generateId(),
-            timestamp: new Date(),
-            taskDescription,
-            context,
-            result: 'failure',
-            details,
-            userFeedback,
-        };
-
-        memory.failures.push(entry);
-        this.saveMemory(memory);
-
-        console.log(`❌ [${agentName}] Falha registrada: ${taskDescription}`);
-    }
-
-    /**
-     * Adiciona um aprendizado
-     */
-    addLearning(
-        agentName: string,
-        pattern: string,
-        description: string,
-        recommendation: string,
-        exampleIds: string[] = []
-    ): void {
-        const memory = this.loadMemory(agentName);
-
-        // Verificar se já existe
-        const existing = memory.learnings.find(l => l.pattern === pattern);
-
-        if (existing) {
-            existing.occurrences++;
-            existing.lastSeen = new Date();
-            existing.confidence = Math.min(1, existing.confidence + 0.1);
-            existing.examples.push(...exampleIds);
-        } else {
-            const learning: Learning = {
-                id: this.generateId(),
-                pattern,
-                description,
-                recommendation,
-                confidence: 0.5,
-                occurrences: 1,
-                lastSeen: new Date(),
-                examples: exampleIds,
-            };
-            memory.learnings.push(learning);
-        }
-
-        this.saveMemory(memory);
-        console.log(`🧠 [${agentName}] Aprendizado adicionado: ${pattern}`);
-    }
-
-    /**
-     * Busca casos similares
-     */
-    getSimilarCases(
-        agentName: string,
-        taskDescription: string,
-        limit: number = 5
-    ): MemoryEntry[] {
-        // Verificar cache primeiro
-        const cacheKey = `similar:${agentName}:${taskDescription}:${limit}`;
-        const cached = this.cache.get<MemoryEntry[]>(cacheKey);
-
-        if (cached) {
-            return cached;
-        }
-
-        // Cache miss - buscar do disco
-        const memory = this.loadMemory(agentName);
-        const allEntries = [...memory.successes, ...memory.failures];
-
-        // Busca simples por palavras-chave
-        const keywords = this.extractKeywords(taskDescription);
-
-        const scored = allEntries.map(entry => {
-            const entryKeywords = this.extractKeywords(entry.taskDescription);
-            const score = this.calculateSimilarity(keywords, entryKeywords);
-            return { entry, score };
-        });
-
-        const results = scored
-            .sort((a, b) => b.score - a.score)
-            .slice(0, limit)
-            .filter(s => s.score > 0.3)
-            .map(s => s.entry);
-
-        // Cachear resultado
-        this.cache.set(cacheKey, results, 60000); // 1 minuto TTL
-
-        return results;
-    }
-
-    /**
-     * Obtém recomendações baseadas em aprendizados
-     */
-    getRecommendations(agentName: string, taskDescription: string): string[] {
-        // Verificar cache primeiro
-        const cacheKey = `recommendations:${agentName}:${taskDescription}`;
-        const cached = this.cache.get<string[]>(cacheKey);
-
-        if (cached) {
-            return cached;
-        }
-
-        // Cache miss - buscar do disco
-        const memory = this.loadMemory(agentName);
-        const keywords = this.extractKeywords(taskDescription);
-
-        const results = memory.learnings
-            .filter(learning => {
-                const patternKeywords = this.extractKeywords(learning.pattern);
-                const similarity = this.calculateSimilarity(keywords, patternKeywords);
-                return similarity > 0.3 && learning.confidence > 0.5;
-            })
-            .sort((a, b) => b.confidence - a.confidence)
-            .map(l => l.recommendation);
-
-        // Cachear resultado
-        this.cache.set(cacheKey, results, 120000); // 2 minutos TTL
-
-        return results;
-    }
-
-    /**
-     * Obtém estatísticas do cache
-     */
-    getCacheStats() {
-        return this.cache.getStats();
-    }
-
-    /**
-     * Limpa o cache
-     */
-    clearCache(): void {
-        this.cache.clear();
-    }
-
-    /**
-     * Obtém estatísticas de um agente
-     */
-    getStats(agentName: string): AgentMemory['stats'] {
-        const memory = this.loadMemory(agentName);
-        return memory.stats;
-    }
-
-    // ==================== Métodos Auxiliares ====================
-
-    private loadJsonFile<T>(filePath: string, defaultValue: T): T {
-        try {
-            if (fs.existsSync(filePath)) {
-                const content = fs.readFileSync(filePath, 'utf-8');
-                const data = JSON.parse(content);
-
-                // Robustez: se o arquivo JSON estiver envolto em um objeto (ex: { "successes": [] })
-                // extraímos o array diretamente
-                const fileName = path.basename(filePath, '.json');
-                if (data && typeof data === 'object' && !Array.isArray(data) && data[fileName]) {
-                    return data[fileName] as T;
-                }
-
-                return data;
-            }
-        } catch (error) {
-            console.warn(`Erro ao carregar ${filePath}:`, error);
-        }
-        return defaultValue;
-    }
-
-    private saveJsonFile(filePath: string, data: any): void {
-        try {
-            fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
-        } catch (error) {
-            console.error(`Erro ao salvar ${filePath}:`, error);
-        }
-    }
-
-    private limitEntries<T extends MemoryEntry>(entries: T[]): T[] {
-        if (entries.length <= this.maxEntries) {
-            return entries;
-        }
-        // Manter as mais recentes
-        return entries
-            .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
-            .slice(0, this.maxEntries);
-    }
-
-    private generateId(): string {
-        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-
-    private extractKeywords(text: string): string[] {
-        return text
-            .toLowerCase()
-            .replace(/[^\w\s]/g, ' ')
-            .split(/\s+/)
-            .filter(word => word.length > 3);
-    }
-
-    private calculateSimilarity(keywords1: string[], keywords2: string[]): number {
-        const set1 = new Set(keywords1);
-        const set2 = new Set(keywords2);
-        const intersection = new Set([...set1].filter(k => set2.has(k)));
-        const union = new Set([...set1, ...set2]);
-
-        return union.size > 0 ? intersection.size / union.size : 0;
-    }
-}

package/.agents/base/skill-manager.ts

@@ -1,95 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface SkillMetadata {
-    name: string;
-    description: string;
-    path: string;
-}
-
-export interface Skill {
-    metadata: SkillMetadata;
-    instructions: string;
-}
-
-export class SkillManager {
-    private skillsPath: string;
-
-    constructor(skillsPath: string = 'skills') {
-        this.skillsPath = path.resolve(process.cwd(), skillsPath);
-    }
-
-    /**
-     * Scans the skills directory for available skills
-     */
-    async listAvailableSkills(): Promise<SkillMetadata[]> {
-        if (!fs.existsSync(this.skillsPath)) return [];
-
-        const skills: SkillMetadata[] = [];
-        const directories = fs.readdirSync(this.skillsPath, { withFileTypes: true })
-            .filter(dirent => dirent.isDirectory());
-
-        for (const dir of directories) {
-            const skillMdPath = path.join(this.skillsPath, dir.name, 'SKILL.md');
-            if (fs.existsSync(skillMdPath)) {
-                const content = fs.readFileSync(skillMdPath, 'utf-8');
-                const metadata = this.parseMetadata(content, path.join(this.skillsPath, dir.name));
-                if (metadata) {
-                    skills.push(metadata);
-                }
-            }
-        }
-
-        return skills;
-    }
-
-    /**
-     * Finds skills relevant to a task description
-     */
-    async getRelevantSkills(taskDescription: string): Promise<Skill[]> {
-        const availableSkills = await this.listAvailableSkills();
-        const relevantSkills: Skill[] = [];
-        const taskLower = taskDescription.toLowerCase();
-
-        for (const meta of availableSkills) {
-            // Simple keyword matching for now
-            // Future improvement: use embeddings/LLM for matching
-            const keywords = meta.description.toLowerCase().split(/\W+/);
-            const matches = keywords.some(kw => kw.length > 3 && taskLower.includes(kw));
-
-            if (matches) {
-                relevantSkills.push(this.loadSkill(meta));
-            }
-        }
-
-        return relevantSkills;
-    }
-
-    private loadSkill(metadata: SkillMetadata): Skill {
-        const skillMdPath = path.join(metadata.path, 'SKILL.md');
-        const content = fs.readFileSync(skillMdPath, 'utf-8');
-
-        // Remove yaml frontmatter
-        const instructions = content.replace(/^---[\s\S]*?---/, '').trim();
-
-        return {
-            metadata,
-            instructions
-        };
-    }
-
-    private parseMetadata(content: string, fullPath: string): SkillMetadata | null {
-        const match = content.match(/^---([\s\S]*?)---/);
-        if (!match) return null;
-
-        const yaml = match[1];
-        const name = yaml.match(/name:\s*(.+)/)?.[1]?.trim();
-        const description = yaml.match(/description:\s*(.+)/)?.[1]?.trim();
-
-        if (name && description) {
-            return { name, description, path: fullPath };
-        }
-
-        return null;
-    }
-}

package/.agents/convert-memory.ps1

@@ -1,153 +0,0 @@
-# PowerShell Script para Converter Memória JSON → MD
-
-Write-Host "`n🔄 Convertendo memória de JSON para Markdown...`n" -ForegroundColor Cyan
-
-$memoryDir = ".agents\memory"
-$agentsDir = ".agents\agents"
-
-# Obter todas as pastas de memória
-$agentMemories = Get-ChildItem $memoryDir -Directory
-
-foreach ($agentMem in $agentMemories) {
-    $agentName = $agentMem.Name -replace "-agent$", ""
-    $targetDir = "$agentsDir\$agentName"
-    
-    if (!(Test-Path $targetDir)) {
-        Write-Host "⚠️  Pasta não encontrada: $targetDir" -ForegroundColor Yellow
-        continue
-    }
-    
-    # Ler JSONs
-    $successesPath = "$($agentMem.FullName)\successes.json"
-    $failuresPath = "$($agentMem.FullName)\failures.json"
-    $learningsPath = "$($agentMem.FullName)\learnings.json"
-    
-    $successes = if (Test-Path $successesPath) { Get-Content $successesPath -Raw | ConvertFrom-Json } else { @() }
-    $failures = if (Test-Path $failuresPath) { Get-Content $failuresPath -Raw | ConvertFrom-Json } else { @() }
-    $learnings = if (Test-Path $learningsPath) { Get-Content $learningsPath -Raw -ErrorAction SilentlyContinue | ConvertFrom-Json } else { @() }
-    
-    # Calcular estatísticas
-    $totalSuccesses = $successes.Count
-    $totalFailures = $failures.Count
-    $totalTasks = $totalSuccesses + $totalFailures
-    $successRate = if ($totalTasks -gt 0) { [math]::Round(($totalSuccesses / $totalTasks) * 100, 1) } else { 0 }
-    $totalLearnings = if ($learnings) { $learnings.Count } else { 0 }
-    
-    # Gerar Markdown
-    $markdown = @"
-# Memória do Agente $agentName
-
-Última atualização: $(Get-Date -Format "yyyy-MM-ddTHH:mm:ssZ")
-
----
-
-## 📊 Estatísticas
-
-- Total de sucessos: $totalSuccesses
-- Total de falhas: $totalFailures
-- Taxa de sucesso: $successRate%
-- Aprendizados acumulados: $totalLearnings
-
----
-
-## ✅ Sucessos Recentes
-
-"@
-    
-    # Sucessos (últimos 10)
-    $recentSuccesses = $successes | Select-Object -Last 10
-    [array]::Reverse($recentSuccesses)
-    
-    if ($recentSuccesses.Count -eq 0) {
-        $markdown += "_Nenhum sucesso registrado ainda._`n`n"
-    }
-    else {
-        foreach ($entry in $recentSuccesses) {
-            $date = (Get-Date $entry.timestamp).ToString("dd/MM/yyyy")
-            $markdown += "### $date - ``$($entry.id)```n`n"
-            $markdown += "**Tarefa**: $($entry.taskDescription)`n`n"
-            $markdown += "**Contexto**:`n"
-            $files = if ($entry.context.files.Count -gt 0) { $entry.context.files -join ", " } else { "nenhum" }
-            $markdown += "- Arquivos: $files`n"
-            $markdown += "- Áreas: $($entry.context.areas -join ', ')`n"
-            $complexity = if ($entry.complexity) { $entry.complexity } else { $entry.context.complexity }
-            $markdown += "- Complexidade: $complexity`n`n"
-            $markdown += "**Resultado**: $($entry.details)`n`n"
-            
-            if ($entry.userFeedback) {
-                $emoji = if ($entry.userFeedback.satisfied) { "👍" } else { "👎" }
-                $markdown += "**Feedback do usuário**: $emoji`n"
-                if ($entry.userFeedback.likes.Count -gt 0) {
-                    $markdown += "- Gostou: $($entry.userFeedback.likes -join ', ')`n"
-                }
-                if ($entry.userFeedback.dislikes.Count -gt 0) {
-                    $markdown += "- Não gostou: $($entry.userFeedback.dislikes -join ', ')`n"
-                }
-                if ($entry.userFeedback.suggestions.Count -gt 0) {
-                    $markdown += "- Sugestões: $($entry.userFeedback.suggestions -join ', ')`n"
-                }
-                $markdown += "`n"
-            }
-        }
-    }
-    
-    $markdown += "---`n`n## ❌ Falhas Registradas`n`n"
-    
-    # Falhas (últimas 10)
-    $recentFailures = $failures | Select-Object -Last 10
-    [array]::Reverse($recentFailures)
-    
-    if ($recentFailures.Count -eq 0) {
-        $markdown += "_Nenhuma falha registrada._`n`n"
-    }
-    else {
-        foreach ($entry in $recentFailures) {
-            $date = (Get-Date $entry.timestamp).ToString("dd/MM/yyyy")
-            $markdown += "### $date - ``$($entry.id)```n`n"
-            $markdown += "**Tarefa**: $($entry.taskDescription)`n`n"
-            $markdown += "**Motivo**: $($entry.details)`n`n"
-            
-            if ($entry.userFeedback -and $entry.userFeedback.suggestions.Count -gt 0) {
-                $markdown += "**Lição aprendida**: $($entry.userFeedback.suggestions -join '; ')`n`n"
-            }
-        }
-    }
-    
-    $markdown += "---`n`n## 🧠 Aprendizados`n`n"
-    
-    # Aprendizados
-    if (!$learnings -or $learnings.Count -eq 0) {
-        $markdown += "_Nenhum aprendizado registrado ainda._`n"
-    }
-    else {
-        $index = 1
-        foreach ($learning in $learnings) {
-            $markdown += "### Aprendizado $index`n`n"
-            $markdown += "**Padrão**: $($learning.pattern)`n`n"
-            $markdown += "**Descrição**: $($learning.description)`n`n"
-            $markdown += "**Recomendação**: $($learning.recommendation)`n`n"
-            $confidence = [math]::Round($learning.confidence * 100, 0)
-            $markdown += "**Confiança**: $confidence%`n`n"
-            
-            if ($learning.exampleIds.Count -gt 0) {
-                $examples = ($learning.exampleIds | ForEach-Object { "``$_``" }) -join ", "
-                $markdown += "**Exemplos**: $examples`n`n"
-            }
-            
-            if ($learning.createdAt) {
-                $date = (Get-Date $learning.createdAt).ToString("dd/MM/yyyy")
-                $markdown += "_Criado em: $date_`n`n"
-            }
-            
-            $index++
-        }
-    }
-    
-    # Salvar memory.md
-    $outputPath = "$targetDir\memory.md"
-    $markdown | Set-Content $outputPath -Encoding UTF8
-    
-    Write-Host "✅ $agentName/memory.md ($totalSuccesses sucessos, $totalFailures falhas, $totalLearnings aprendizados)" -ForegroundColor Green
-}
-
-Write-Host "`n✅ Conversão de memória concluída!`n" -ForegroundColor Cyan