wegho-agentes 7.0.0 → 7.0.1

package/.agents/utils/context-monitor.ts

@@ -1,140 +0,0 @@
-/**
- * Context Monitor - Monitora nível de contexto do LLM
- */
-
-export type ContextLevel = 'baixo' | 'baixo-médio' | 'médio' | 'médio-alto' | 'alto' | 'muito-alto' | 'extremo';
-
-export interface ContextReport {
-    level: ContextLevel;
-    percentage: number;
-    emoji: string;
-    warning: string;
-    color: 'green' | 'yellow' | 'orange' | 'red';
-    shouldWarn: boolean;
-}
-
-export class ContextMonitor {
-    private maxTokens: number;
-
-    constructor(maxTokens: number = 200000) {
-        this.maxTokens = maxTokens;
-    }
-
-    /**
-     * Analisa nível de contexto e retorna relatório
-     */
-    getContextLevel(currentTokens: number): ContextReport {
-        const percentage = (currentTokens / this.maxTokens) * 100;
-
-        // Definir nível baseado em percentage
-        let level: ContextLevel;
-        let emoji: string;
-        let warning: string;
-        let color: 'green' | 'yellow' | 'orange' | 'red';
-        let shouldWarn: boolean;
-
-        if (percentage < 20) {
-            level = 'baixo';
-            emoji = '🟢';
-            warning = 'Contexto saudável. Continue.';
-            color = 'green';
-            shouldWarn = false;
-        } else if (percentage < 40) {
-            level = 'baixo-médio';
-            emoji = '🟢';
-            warning = 'Contexto baixo-médio. Espaço suficiente.';
-            color = 'green';
-            shouldWarn = false;
-        } else if (percentage < 60) {
-            level = 'médio';
-            emoji = '🟡';
-            warning = 'Contexto médio. Monitore o crescimento.';
-            color = 'yellow';
-            shouldWarn = false;
-        } else if (percentage < 80) {
-            level = 'médio-alto';
-            emoji = '🟠';
-            warning = 'Contexto médio-alto. Planeje finalizar tarefas em breve.';
-            color = 'orange';
-            shouldWarn = false;
-        } else if (percentage < 90) {
-            level = 'alto';
-            emoji = '🟠';
-            warning = 'Contexto alto! Considere finalizar a tarefa atual.';
-            color = 'orange';
-            shouldWarn = true;
-        } else if (percentage < 95) {
-            level = 'muito-alto';
-            emoji = '🔴';
-            warning = '⚠️ Contexto MUITO ALTO! Recomendo iniciar nova conversa após esta tarefa.';
-            color = 'red';
-            shouldWarn = true;
-        } else {
-            level = 'extremo';
-            emoji = '🔴';
-            warning = '🚨 CONTEXTO EXTREMO! INICIE NOVA CONVERSA IMEDIATAMENTE!';
-            color = 'red';
-            shouldWarn = true;
-        }
-
-        return {
-            level,
-            percentage: Math.round(percentage * 10) / 10,
-            emoji,
-            warning,
-            color,
-            shouldWarn
-        };
-    }
-
-    /**
-     * Verifica se deve alertar o usuário
-     */
-    shouldWarnUser(currentTokens: number): boolean {
-        const report = this.getContextLevel(currentTokens);
-        return report.shouldWarn;
-    }
-
-    /**
-     * Gera relatório visual de contexto
-     */
-    generateReport(currentTokens: number): string {
-        const report = this.getContextLevel(currentTokens);
-
-        let visual = '📊 NÍVEL DE CONTEXTO\\n';
-        visual += `${report.emoji} **${report.level.toUpperCase()}** (${report.percentage}%)\\n`;
-        visual += `\\n${report.warning}\\n`;
-
-        // Barra de progresso visual
-        visual += '\\n' + this.generateProgressBar(report.percentage);
-
-        if (report.shouldWarn) {
-            visual += '\\n\\n⚠️ **AÇÃO RECOMENDADA**: Considere iniciar nova conversa após completar a tarefa atual.';
-        }
-
-        return visual;
-    }
-
-    /**
-     * Gera barra de progresso ASCII
-     */
-    private generateProgressBar(percentage: number): string {
-        const barLength = 30;
-        const filled = Math.round((percentage / 100) * barLength);
-        const empty = barLength - filled;
-
-        const bar = '█'.repeat(filled) + '░'.repeat(empty);
-        return `[${bar}] ${percentage}%`;
-    }
-
-    /**
-     * Estima tokens após uma tarefa (útil para planejamento)
-     */
-    estimateAfterTask(currentTokens: number, estimatedTaskTokens: number): ContextReport {
-        const projectedTokens = currentTokens + estimatedTaskTokens;
-        return this.getContextLevel(projectedTokens);
-    }
-}
-
-// Singleton global (assume 200k tokens max para Gemini/Claude)
-export const globalContextMonitor = new ContextMonitor(200000);

package/.agents/utils/feedback-collector.ts

@@ -1,207 +0,0 @@
-/**
- * Feedback Collector - Coletor de Feedback do Usuário
- * 
- * Responsabilidades:
- * - Coletar feedback do usuário após tarefas
- * - Registrar feedback na memória dos agentes
- * - Analisar padrões em feedbacks
- * - Gerar sugestões baseadas em histórico
- */
-
-import { MemorySystem, MemoryEntry } from './memory-system';
-import { TaskContext } from './base-agent';
-
-export interface UserFeedback {
-    taskId: string;
-    agentName: string;
-    satisfied: boolean;
-    likes: string[];
-    dislikes: string[];
-    suggestions: string[];
-    timestamp: Date;
-}
-
-export interface FeedbackPrompt {
-    question: string;
-    type: 'boolean' | 'text' | 'multipleChoice';
-    options?: string[];
-}
-
-export class FeedbackCollector {
-    private memory: MemorySystem;
-
-    constructor(memoryBasePath: string = '.agents/memory') {
-        this.memory = new MemorySystem(memoryBasePath);
-    }
-
-    /**
-     * Coleta feedback do usuário (simulado - em produção seria interativo)
-     */
-    async collectFeedback(
-        taskId: string,
-        agentName: string,
-        taskDescription: string
-    ): Promise<UserFeedback | null> {
-        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('📝 FEEDBACK DO USUÁRIO');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-        console.log(`Tarefa: ${taskDescription}`);
-        console.log(`Agente: ${agentName}\n`);
-
-        // Em produção, isso seria um prompt interativo
-        // Por enquanto, retornamos null para indicar que o feedback será coletado manualmente
-        console.log('💡 Para fornecer feedback, use o método provideFeedback()');
-        console.log('   Exemplo: feedbackCollector.provideFeedback(taskId, agentName, {...})\n');
-
-        return null;
-    }
-
-    /**
-     * Fornece feedback manualmente
-     */
-    async provideFeedback(feedback: UserFeedback): Promise<void> {
-        console.log(`\n✅ Feedback recebido para ${feedback.agentName}`);
-        console.log(`   Satisfeito: ${feedback.satisfied ? '👍 Sim' : '👎 Não'}`);
-
-        if (feedback.likes.length > 0) {
-            console.log(`   Gostou: ${feedback.likes.join(', ')}`);
-        }
-
-        if (feedback.dislikes.length > 0) {
-            console.log(`   Não gostou: ${feedback.dislikes.join(', ')}`);
-        }
-
-        if (feedback.suggestions.length > 0) {
-            console.log(`   Sugestões: ${feedback.suggestions.join(', ')}`);
-        }
-
-        // Analisar feedback e gerar aprendizados
-        await this.analyzeFeedback(feedback);
-    }
-
-    /**
-     * Analisa feedback e gera aprendizados
-     */
-    private async analyzeFeedback(feedback: UserFeedback): Promise<void> {
-        // Se não está satisfeito, criar aprendizado negativo
-        if (!feedback.satisfied && feedback.dislikes.length > 0) {
-            for (const dislike of feedback.dislikes) {
-                this.memory.addLearning(
-                    feedback.agentName,
-                    `Evitar: ${dislike}`,
-                    `Usuário não gostou de: ${dislike}`,
-                    `Evitar fazer: ${dislike}`,
-                    [feedback.taskId]
-                );
-            }
-        }
-
-        // Se está satisfeito, criar aprendizado positivo
-        if (feedback.satisfied && feedback.likes.length > 0) {
-            for (const like of feedback.likes) {
-                this.memory.addLearning(
-                    feedback.agentName,
-                    `Repetir: ${like}`,
-                    `Usuário gostou de: ${like}`,
-                    `Continuar fazendo: ${like}`,
-                    [feedback.taskId]
-                );
-            }
-        }
-
-        // Processar sugestões
-        if (feedback.suggestions.length > 0) {
-            for (const suggestion of feedback.suggestions) {
-                this.memory.addLearning(
-                    feedback.agentName,
-                    `Sugestão: ${suggestion}`,
-                    `Usuário sugeriu: ${suggestion}`,
-                    `Considerar implementar: ${suggestion}`,
-                    [feedback.taskId]
-                );
-            }
-        }
-
-        console.log(`\n🧠 Aprendizados registrados para ${feedback.agentName}`);
-    }
-
-    /**
-     * Obtém padrões de feedback
-     */
-    getFeedbackPatterns(agentName: string): {
-        commonLikes: string[];
-        commonDislikes: string[];
-        commonSuggestions: string[];
-    } {
-        const agentMemory = this.memory.loadMemory(agentName);
-
-        // Extrair padrões dos aprendizados
-        const likes = agentMemory.learnings
-            .filter(l => l.pattern.startsWith('Repetir:'))
-            .sort((a, b) => b.occurrences - a.occurrences)
-            .slice(0, 5)
-            .map(l => l.pattern.replace('Repetir: ', ''));
-
-        const dislikes = agentMemory.learnings
-            .filter(l => l.pattern.startsWith('Evitar:'))
-            .sort((a, b) => b.occurrences - a.occurrences)
-            .slice(0, 5)
-            .map(l => l.pattern.replace('Evitar: ', ''));
-
-        const suggestions = agentMemory.learnings
-            .filter(l => l.pattern.startsWith('Sugestão:'))
-            .sort((a, b) => b.occurrences - a.occurrences)
-            .slice(0, 5)
-            .map(l => l.pattern.replace('Sugestão: ', ''));
-
-        return {
-            commonLikes: likes,
-            commonDislikes: dislikes,
-            commonSuggestions: suggestions,
-        };
-    }
-
-    /**
-     * Gera relatório de feedback
-     */
-    generateFeedbackReport(agentName: string): string {
-        const patterns = this.getFeedbackPatterns(agentName);
-        const stats = this.memory.getStats(agentName);
-
-        let report = `\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
-        report += `📊 RELATÓRIO DE FEEDBACK - ${agentName}\n`;
-        report += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
-
-        report += `📈 Estatísticas:\n`;
-        report += `   Total de tarefas: ${stats.totalTasks}\n`;
-        report += `   Taxa de sucesso: ${(stats.successRate * 100).toFixed(1)}%\n\n`;
-
-        if (patterns.commonLikes.length > 0) {
-            report += `👍 O que os usuários mais gostam:\n`;
-            patterns.commonLikes.forEach((like, i) => {
-                report += `   ${i + 1}. ${like}\n`;
-            });
-            report += `\n`;
-        }
-
-        if (patterns.commonDislikes.length > 0) {
-            report += `👎 O que os usuários não gostam:\n`;
-            patterns.commonDislikes.forEach((dislike, i) => {
-                report += `   ${i + 1}. ${dislike}\n`;
-            });
-            report += `\n`;
-        }
-
-        if (patterns.commonSuggestions.length > 0) {
-            report += `💡 Sugestões recorrentes:\n`;
-            patterns.commonSuggestions.forEach((suggestion, i) => {
-                report += `   ${i + 1}. ${suggestion}\n`;
-            });
-            report += `\n`;
-        }
-
-        report += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
-
-        return report;
-    }
-}

package/.agents/utils/file-generator.ts

@@ -1,304 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { ImplementationPlan } from './planning-agent.js';
-
-/**
- * File Generator - Gera código inteligente baseado em planos
- * 
- * Responsabilidades:
- * - Gerar componentes React/Next.js
- * - Gerar APIs/endpoints
- * - Gerar hooks customizados
- * - Gerar tipos TypeScript
- * - Modificar arquivos existentes
- */
-
-export class FileGenerator {
-    private projectRoot: string;
-
-    constructor(projectRoot: string = process.cwd()) {
-        this.projectRoot = projectRoot;
-    }
-
-    /**
-     * Cria arquivo baseado no plano
-     */
-    async createFile(
-        filePath: string,
-        type: 'component' | 'api' | 'hook' | 'util' | 'type' | 'config',
-        purpose: string,
-        plan: ImplementationPlan
-    ): Promise<void> {
-        const fullPath = path.join(this.projectRoot, filePath);
-        const dir = path.dirname(fullPath);
-
-        // Criar diretório se não existir
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-
-        // Gerar conteúdo baseado no tipo
-        let content = '';
-
-        switch (type) {
-            case 'component':
-                content = this.generateComponent(filePath, purpose, plan);
-                break;
-            case 'api':
-                content = this.generateAPI(filePath, purpose, plan);
-                break;
-            case 'hook':
-                content = this.generateHook(filePath, purpose, plan);
-                break;
-            case 'util':
-                content = this.generateUtil(filePath, purpose);
-                break;
-            case 'type':
-                content = this.generateType(filePath, purpose);
-                break;
-            case 'config':
-                content = this.generateConfig(filePath, purpose);
-                break;
-        }
-
-        // Escrever arquivo
-        fs.writeFileSync(fullPath, content, 'utf-8');
-        console.log(`   ✨ Criado: ${filePath}`);
-    }
-
-    /**
-     * Modifica arquivo existente
-     */
-    async modifyFile(filePath: string, changes: string): Promise<void> {
-        const fullPath = path.join(this.projectRoot, filePath);
-
-        if (!fs.existsSync(fullPath)) {
-            console.warn(`   ⚠️  Arquivo não existe: ${filePath}`);
-            return;
-        }
-
-        const content = fs.readFileSync(fullPath, 'utf-8');
-
-        // Aqui seria ideal ter lógica mais sofisticada de modificação
-        // Por enquanto, apenas adiciona comentário indicando mudança necessária
-        const modifiedContent = content + `\n\n// TODO: ${changes}\n`;
-
-        fs.writeFileSync(fullPath, modifiedContent, 'utf-8');
-        console.log(`   ✏️  Modificado: ${filePath}`);
-    }
-
-    /**
-     * Gera componente React
-     */
-    private generateComponent(filePath: string, purpose: string, plan: ImplementationPlan): string {
-        const componentName = path.basename(filePath, '.tsx');
-        const hasAuth = plan.architecture.components.some(c => c.includes('Auth'));
-
-        return `'use client';
-
-import { FC } from 'react';
-
-/**
- * ${componentName}
- * 
- * ${purpose}
- */
-
-interface ${componentName}Props {
-    // TODO: Adicionar props necessárias
-}
-
-export const ${componentName}: FC<${componentName}Props> = (props) => {
-    return (
-        <div className="p-4">
-            <h2 className="text-2xl font-bold">${componentName}</h2>
-            {/* TODO: Implementar UI */}
-        </div>
-    );
-};
-
-export default ${componentName};
-`;
-    }
-
-    /**
-     * Gera API route
-     */
-    private generateAPI(filePath: string, purpose: string, plan: ImplementationPlan): string {
-        const hasDatabase = plan.architecture.database.length > 0;
-
-        return `import { NextRequest, NextResponse } from 'next/server';
-${hasDatabase ? "import { createClient } from '@/lib/supabase/server';" : ''}
-
-/**
- * ${purpose}
- */
-
-export async function GET(request: NextRequest) {
-    try {
-        ${hasDatabase ? `
-        const supabase = createClient();
-        
-        // TODO: Implementar query
-        const { data, error } = await supabase
-            .from('table_name')
-            .select('*');
-
-        if (error) throw error;
-        ` : `
-        // TODO: Implementar lógica
-        const data = { message: 'Success' };
-        `}
-
-        return NextResponse.json(data);
-    } catch (error) {
-        console.error('API Error:', error);
-        return NextResponse.json(
-            { error: 'Internal Server Error' },
-            { status: 500 }
-        );
-    }
-}
-
-export async function POST(request: NextRequest) {
-    try {
-        const body = await request.json();
-        
-        ${hasDatabase ? `
-        const supabase = createClient();
-        
-        // TODO: Implementar insert/update
-        const { data, error } = await supabase
-            .from('table_name')
-            .insert(body)
-            .select()
-            .single();
-
-        if (error) throw error;
-        ` : `
-        // TODO: Implementar lógica
-        const data = { success: true, ...body };
-        `}
-
-        return NextResponse.json(data);
-    } catch (error) {
-        console.error('API Error:', error);
-        return NextResponse.json(
-            { error: 'Internal Server Error' },
-            { status: 500 }
-        );
-    }
-}
-`;
-    }
-
-    /**
-     * Gera hook customizado
-     */
-    private generateHook(filePath: string, purpose: string, plan: ImplementationPlan): string {
-        const hookName = path.basename(filePath, '.ts');
-
-        return `import { useState, useEffect } from 'react';
-
-/**
- * ${hookName}
- * 
- * ${purpose}
- */
-
-export function ${hookName}() {
-    const [data, setData] = useState<any>(null);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState<Error | null>(null);
-
-    useEffect(() => {
-        async function fetchData() {
-            try {
-                setLoading(true);
-                
-                // TODO: Implementar lógica
-                const response = await fetch('/api/endpoint');
-                const result = await response.json();
-                
-                setData(result);
-            } catch (err) {
-                setError(err as Error);
-            } finally {
-                setLoading(false);
-            }
-        }
-
-        fetchData();
-    }, []);
-
-    return { data, loading, error };
-}
-`;
-    }
-
-    /**
-     * Gera arquivo de utilidades
-     */
-    private generateUtil(filePath: string, purpose: string): string {
-        return `/**
- * Utilities
- * 
- * ${purpose}
- */
-
-export function exampleUtil(input: string): string {
-    // TODO: Implementar lógica
-    return input;
-}
-`;
-    }
-
-    /**
-     * Gera arquivo de tipos
-     */
-    private generateType(filePath: string, purpose: string): string {
-        return `/**
- * Types
- * 
- * ${purpose}
- */
-
-export interface ExampleType {
-    id: string;
-    // TODO: Adicionar campos
-}
-
-export type ExampleUnion = 'option1' | 'option2';
-`;
-    }
-
-    /**
-     * Gera arquivo de configuração
-     */
-    private generateConfig(filePath: string, purpose: string): string {
-        return `/**
- * Configuration
- * 
- * ${purpose}
- */
-
-export const config = {
-    // TODO: Adicionar configurações
-};
-
-export default config;
-`;
-    }
-
-    /**
-     * Deleta arquivo
-     */
-    async deleteFile(filePath: string): Promise<void> {
-        const fullPath = path.join(this.projectRoot, filePath);
-
-        if (fs.existsSync(fullPath)) {
-            fs.unlinkSync(fullPath);
-            console.log(`   🗑️  Deletado: ${filePath}`);
-        }
-    }
-}