wegho-agentes 4.0.1

package/.agents/domains/news/seo-agent.ts

@@ -0,0 +1,170 @@
+/**
+ * SEO Agent (com Memória)
+ * Domínio: Site de Notícias
+ * 
+ * Responsabilidades:
+ * - Validar meta tags (title, description, og:image)
+ * - Verificar structured data (JSON-LD)
+ * - Sugerir otimizações de performance
+ * - Validar sitemap.xml
+ * - Aprender padrões de SEO que funcionam
+ */
+
+import { BaseAgent, TaskContext, TaskResult } from '../../core/base-agent';
+
+export interface SEOMetadata {
+    title?: string;
+    description?: string;
+    keywords?: string[];
+    ogImage?: string;
+    ogType?: string;
+    canonicalUrl?: string;
+}
+
+export class SEOAgent extends BaseAgent {
+    constructor(memoryBasePath: string = '.agents/memory') {
+        super('seo-agent', memoryBasePath);
+    }
+
+    /**
+     * Implementação da validação de SEO
+     */
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        const warnings: string[] = [];
+        const recommendations: string[] = [];
+
+        // Aqui seria feita a validação real de SEO
+        // Por enquanto, retorna sucesso
+        const success = warnings.length === 0;
+        const details = success
+            ? 'SEO validado com sucesso'
+            : `Avisos: ${warnings.join(', ')}`;
+
+        return {
+            success,
+            details,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            recommendations: recommendations.length > 0 ? recommendations : undefined
+        };
+    }
+
+    /**
+     * Valida meta tags
+     */
+    validateMetaTags(metadata: SEOMetadata): { valid: boolean; warnings: string[]; recommendations: string[] } {
+        const warnings: string[] = [];
+        const recommendations: string[] = [];
+
+        // Title
+        if (!metadata.title) {
+            warnings.push('Meta title ausente');
+        } else if (metadata.title.length > 60) {
+            warnings.push(`Meta title muito longo (${metadata.title.length} caracteres, ideal: 50-60)`);
+        } else if (metadata.title.length < 30) {
+            recommendations.push('Meta title poderia ser mais descritivo (mínimo recomendado: 30 caracteres)');
+        }
+
+        // Description
+        if (!metadata.description) {
+            warnings.push('Meta description ausente');
+        } else if (metadata.description.length > 160) {
+            warnings.push(`Meta description muito longa (${metadata.description.length} caracteres, ideal: 150-160)`);
+        } else if (metadata.description.length < 100) {
+            recommendations.push('Meta description poderia ser mais descritiva (mínimo recomendado: 100 caracteres)');
+        }
+
+        // Open Graph
+        if (!metadata.ogImage) {
+            recommendations.push('Adicionar og:image para melhor compartilhamento em redes sociais');
+        }
+
+        if (!metadata.canonicalUrl) {
+            recommendations.push('Adicionar canonical URL para evitar conteúdo duplicado');
+        }
+
+        return { valid: warnings.length === 0, warnings, recommendations };
+    }
+
+    /**
+     * Gera structured data (JSON-LD) para artigo
+     */
+    generateArticleStructuredData(article: {
+        title: string;
+        description: string;
+        author: string;
+        publishedDate: string;
+        imageUrl: string;
+    }): string {
+        return JSON.stringify({
+            '@context': 'https://schema.org',
+            '@type': 'NewsArticle',
+            headline: article.title,
+            description: article.description,
+            author: {
+                '@type': 'Person',
+                name: article.author,
+            },
+            datePublished: article.publishedDate,
+            image: article.imageUrl,
+        }, null, 2);
+    }
+
+    /**
+     * Valida sitemap.xml
+     */
+    validateSitemap(sitemapContent: string): { valid: boolean; errors: string[] } {
+        const errors: string[] = [];
+
+        if (!sitemapContent.includes('<?xml')) {
+            errors.push('Sitemap deve começar com declaração XML');
+        }
+
+        if (!sitemapContent.includes('<urlset')) {
+            errors.push('Sitemap deve conter elemento <urlset>');
+        }
+
+        if (!sitemapContent.includes('<loc>')) {
+            errors.push('Sitemap deve conter ao menos uma <loc> (URL)');
+        }
+
+        return { valid: errors.length === 0, errors };
+    }
+
+    /**
+     * Especialidade padrão do SEO Agent
+     */
+    protected getDefaultSpecialty(): string {
+        return `# SEO Agent - Especialidade
+
+## Responsabilidades
+- Validar meta tags (title, description, og:image)
+- Verificar structured data (JSON-LD)
+- Sugerir otimizações de SEO
+- Validar sitemap.xml
+- Garantir URLs SEO-friendly
+
+## Expertise
+- SEO On-Page
+- Meta Tags e Open Graph
+- Structured Data (Schema.org)
+- Sitemap e Robots.txt
+- Core Web Vitals
+- Google Search Console
+
+## Regras
+- Meta title: 50-60 caracteres
+- Meta description: 150-160 caracteres
+- Sempre incluir og:image
+- Usar canonical URL
+- Structured data para artigos
+- Sitemap atualizado
+
+## Tarefas Típicas
+- Validar meta tags de páginas
+- Gerar structured data
+- Otimizar títulos e descrições
+- Validar sitemap
+- Sugerir melhorias de SEO
+`;
+    }
+}

package/.agents/domains/production/production-control-agent.ts

@@ -0,0 +1,169 @@
+/**
+ * Production Control Agent (com Memória)
+ * Domínio: Produção e Expedição
+ * 
+ * Responsabilidades:
+ * - Monitorar eventos de produção
+ * - Validar fluxo (inicio → processamento → conclusão)
+ * - Alertar sobre gargalos ou atrasos
+ * - Validar schema Supabase
+ * - Aprender padrões de produção eficientes
+ */
+
+import { BaseAgent, TaskContext, TaskResult } from '../../core/base-agent';
+
+export interface ProductionEvent {
+    id: string;
+    event_type: 'start' | 'processing' | 'complete' | 'pause';
+    timestamp: string;
+    shift: string;
+    quantity: number;
+    operator_id: string;
+}
+
+export class ProductionControlAgent extends BaseAgent {
+    constructor(memoryBasePath: string = '.agents/memory') {
+        super('production-control-agent', memoryBasePath);
+    }
+
+    /**
+     * Implementação da validação de produção
+     */
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        const issues: string[] = [];
+        const warnings: string[] = [];
+
+        // Aqui seria feita a validação real de eventos de produção
+        const success = issues.length === 0;
+        const details = success
+            ? 'Controle de produção validado com sucesso'
+            : `Problemas encontrados: ${issues.join(', ')}`;
+
+        return {
+            success,
+            details,
+            issues: issues.length > 0 ? issues : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined
+        };
+    }
+
+    /**
+     * Valida evento de produção
+     */
+    validateEvent(event: Partial<ProductionEvent>): { valid: boolean; errors: string[] } {
+        const errors: string[] = [];
+
+        if (!event.event_type) {
+            errors.push('Tipo de evento é obrigatório');
+        } else if (!['start', 'processing', 'complete', 'pause'].includes(event.event_type)) {
+            errors.push('Tipo de evento inválido (permitidos: start, processing, complete, pause)');
+        }
+
+        if (!event.timestamp) {
+            errors.push('Timestamp é obrigatório');
+        }
+
+        if (!event.shift) {
+            errors.push('Turno (shift) é obrigatório');
+        }
+
+        if (event.quantity !== undefined && event.quantity < 0) {
+            errors.push('Quantidade não pode ser negativa');
+        }
+
+        if (!event.operator_id) {
+            errors.push('Operador é obrigatório');
+        }
+
+        return { valid: errors.length === 0, errors };
+    }
+
+    /**
+     * Detecta gargalos em eventos
+     */
+    detectBottlenecks(events: ProductionEvent[]): string[] {
+        const bottlenecks: string[] = [];
+
+        // Detectar eventos em "processing" por muito tempo (>2h exemplo)
+        const now = new Date();
+        events.forEach(event => {
+            if (event.event_type === 'processing') {
+                const eventTime = new Date(event.timestamp);
+                const diffHours = (now.getTime() - eventTime.getTime()) / (1000 * 60 * 60);
+
+                if (diffHours > 2) {
+                    bottlenecks.push(`Evento ${event.id} em processamento há ${diffHours.toFixed(1)} horas`);
+                }
+            }
+        });
+
+        // Detectar pausas frequentes
+        const pauseEvents = events.filter(e => e.event_type === 'pause');
+        if (pauseEvents.length > 5) {
+            bottlenecks.push(`Muitas pausas detectadas (${pauseEvents.length})`);
+        }
+
+        return bottlenecks;
+    }
+
+    /**
+     * Valida schema Supabase
+     */
+    validateSchema(migrations: string[]): { valid: boolean; recommendations: string[] } {
+        const recommendations: string[] = [];
+
+        const hasProductionEvents = migrations.some(m => m.includes('create table production_events'));
+        const hasPlantLogs = migrations.some(m => m.includes('create table plant_logs'));
+        const hasMiningCycles = migrations.some(m => m.includes('create table mining_cycles'));
+
+        if (!hasProductionEvents) {
+            recommendations.push('Criar tabela "production_events" (id, event_type, timestamp, shift, quantity, operator_id)');
+        }
+
+        if (!hasPlantLogs) {
+            recommendations.push('Criar tabela "plant_logs" (id, plant_id, log_type, timestamp, data)');
+        }
+
+        if (!hasMiningCycles) {
+            recommendations.push('Criar tabela "mining_cycles" (id, cycle_start, cycle_end, location, quantity)');
+        }
+
+        return { valid: recommendations.length === 0, recommendations };
+    }
+
+    /**
+     * Especialidade padrão do Production Control Agent
+     */
+    protected getDefaultSpecialty(): string {
+        return `# Production Control Agent - Especialidade
+
+## Responsabilidades
+- Monitorar eventos de produção
+- Validar fluxo (inicio → processamento → conclusão)
+- Alertar sobre gargalos ou atrasos
+- Validar schema Supabase para produção
+- Otimizar processos de produção
+
+## Expertise
+- Controle de Produção
+- Gestão de Turnos
+- Detecção de Gargalos
+- KPIs de Produção
+- Mineração e Expedição
+
+## Regras
+- Eventos devem seguir fluxo: start → processing → complete
+- Pausas devem ser justificadas
+- Quantidade não pode ser negativa
+- Operador deve estar vinculado
+- Monitorar tempo de processamento
+
+## Tarefas Típicas
+- Validar eventos de produção
+- Detectar gargalos em tempo real
+- Sugerir otimizações de processo
+- Validar schema de banco de dados
+- Gerar relatórios de produção
+`;
+    }
+}

package/.agents/example-learning-system.js

@@ -0,0 +1,118 @@
+/**
+ * Exemplo de Uso do Sistema de Agentes com Aprendizado
+ * 
+ * Este script demonstra como usar o novo sistema de agentes com memória e aprendizado contínuo.
+ */
+
+const { IntelligentOrchestrator } = require('./orchestrator');
+const { ContextLoader } = require('./context-loader');
+
+async function main() {
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('🚀 SISTEMA DE AGENTES COM APRENDIZADO CONTÍNUO');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+    // 1. Carregar contexto do projeto
+    console.log('📂 Carregando contexto do projeto...\n');
+    const contextLoader = new ContextLoader();
+    const context = await contextLoader.loadContext();
+
+    // 2. Criar orquestrador inteligente
+    const orchestrator = new IntelligentOrchestrator(context);
+
+    // 3. Exemplo 1: Criar componente de login
+    console.log('\n━━━ EXEMPLO 1: Criar Componente de Login ━━━\n');
+
+    const result1 = await orchestrator.orchestrateTask(
+        'Criar componente de login com validação de email e senha, estados de loading e error, e acessibilidade'
+    );
+
+    console.log(`\nResultado: ${result1.status}`);
+    console.log(`Task ID: ${result1.taskId}\n`);
+
+    // 4. Fornecer feedback positivo
+    if (result1.success) {
+        console.log('━━━ Fornecendo Feedback Positivo ━━━\n');
+
+        await orchestrator.provideFeedback(result1.taskId, 'frontend-agent', {
+            satisfied: true,
+            likes: [
+                'Validação de inputs implementada corretamente',
+                'Estados de loading e error incluídos',
+                'Acessibilidade com aria-labels'
+            ],
+            dislikes: [],
+            suggestions: [
+                'Adicionar animação de transição'
+            ]
+        });
+
+        await orchestrator.provideFeedback(result1.taskId, 'security-agent', {
+            satisfied: true,
+            likes: [
+                'Validação de senha forte',
+                'Proteção contra XSS'
+            ],
+            dislikes: [],
+            suggestions: []
+        });
+    }
+
+    // 5. Exemplo 2: Criar componente similar (agentes devem aprender)
+    console.log('\n━━━ EXEMPLO 2: Criar Componente de Registro (Similar) ━━━\n');
+
+    const result2 = await orchestrator.orchestrateTask(
+        'Criar componente de registro com validação de email, senha e confirmação de senha'
+    );
+
+    console.log(`\nResultado: ${result2.status}`);
+    console.log(`Task ID: ${result2.taskId}\n`);
+
+    // 6. Ver relatórios de feedback
+    console.log('\n━━━ RELATÓRIOS DE FEEDBACK ━━━\n');
+
+    console.log(orchestrator.getFeedbackReport('frontend-agent'));
+    console.log(orchestrator.getFeedbackReport('security-agent'));
+
+    // 7. Exemplo 3: Tarefa com problema (para testar aprendizado de falhas)
+    console.log('\n━━━ EXEMPLO 3: Componente com Problema ━━━\n');
+
+    const result3 = await orchestrator.orchestrateTask(
+        'Criar componente que usa dangerouslySetInnerHTML sem sanitização'
+    );
+
+    console.log(`\nResultado: ${result3.status}`);
+
+    if (!result3.success) {
+        console.log('Bloqueadores detectados:');
+        result3.blockers.forEach(blocker => console.log(`  - ${blocker}`));
+
+        // Fornecer feedback negativo
+        await orchestrator.provideFeedback(result3.taskId, 'security-agent', {
+            satisfied: false,
+            likes: [],
+            dislikes: [
+                'Detectou vulnerabilidade XSS corretamente'
+            ],
+            suggestions: [
+                'Sugerir DOMPurify automaticamente'
+            ]
+        });
+    }
+
+    console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('✅ DEMONSTRAÇÃO CONCLUÍDA');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+    console.log('💡 Dicas:');
+    console.log('  - Memória dos agentes está em .agents/memory/');
+    console.log('  - Cada agente tem: successes.json, failures.json, learnings.json');
+    console.log('  - Agentes aprendem com feedback e evitam repetir erros');
+    console.log('  - Orquestrador seleciona agentes com melhor histórico\n');
+}
+
+// Executar
+main().catch(error => {
+    console.error('❌ Erro:', error);
+    process.exit(1);
+});

package/.agents/init.ts

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+/**
+ * 🚀 SCRIPT DE INICIALIZAÇÃO DO SISTEMA DE AGENTES
+ * 
+ * Este script é executado quando alguém instala o sistema pela primeira vez.
+ * Ele:
+ * 1. Pede permissão para escanear o projeto
+ * 2. Inicializa o orquestrador
+ * 3. Cria memória inicial para TODOS os agentes
+ * 4. Organiza o almoxarifado (Inventory Agent)
+ */
+
+import * as readline from 'readline';
+import * as path from 'path';
+import { InventoryAgent } from './core/inventory-agent';
+import { FrontEndAgent } from './core/frontend-agent';
+import { SecurityAgent } from './core/security-agent';
+import { ArchitectureAgent } from './core/architecture-agent';
+import { QualityAgent } from './core/quality-agent';
+import { DocumentationAgent } from './core/documentation-agent';
+import { CMSAgent } from './domains/news/cms-agent';
+import { SEOAgent } from './domains/news/seo-agent';
+import { ProductionControlAgent } from './domains/production/production-control-agent';
+import { RouteAgent } from './domains/logistics/route-agent';
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+
+function question(query: string): Promise<string> {
+    return new Promise((resolve) => {
+        rl.question(query, resolve);
+    });
+}
+
+async function main() {
+    console.log('\n' + '='.repeat(60));
+    console.log('🤖 BEM-VINDO AO SISTEMA DE AGENTES INTELIGENTES');
+    console.log('='.repeat(60) + '\n');
+
+    console.log('Este é o processo de inicialização do sistema.');
+    console.log('O orquestrador irá preparar TODOS os agentes para trabalhar.\n');
+
+    // 1. Pedir permissão
+    const permission = await question(
+        '❓ Posso escanear seu projeto e criar a memória inicial para todos os agentes? (s/n): '
+    );
+
+    if (permission.toLowerCase() !== 's' && permission.toLowerCase() !== 'sim') {
+        console.log('\n❌ Inicialização cancelada pelo usuário.');
+        console.log('Execute novamente quando estiver pronto: npm run init\n');
+        rl.close();
+        return;
+    }
+
+    console.log('\n✅ Permissão concedida! Iniciando...\n');
+
+    const projectRoot = process.cwd();
+
+    // 2. Inicializar agentes
+    console.log('📦 Inicializando agentes...\n');
+
+    const memoryPath = path.join(projectRoot, '.agents', 'memory');
+
+    const agents = [
+        { name: 'Inventory Agent', agent: new InventoryAgent(projectRoot, memoryPath), priority: 1 },
+        { name: 'Frontend Agent', agent: new FrontEndAgent(memoryPath), priority: 2 },
+        { name: 'Security Agent', agent: new SecurityAgent(memoryPath), priority: 2 },
+        { name: 'Architecture Agent', agent: new ArchitectureAgent(memoryPath), priority: 2 },
+        { name: 'Quality Agent', agent: new QualityAgent(memoryPath), priority: 2 },
+        { name: 'Documentation Agent', agent: new DocumentationAgent(memoryPath), priority: 2 },
+        { name: 'CMS Agent', agent: new CMSAgent(memoryPath), priority: 3 },
+        { name: 'SEO Agent', agent: new SEOAgent(memoryPath), priority: 3 },
+        { name: 'Production Control Agent', agent: new ProductionControlAgent(memoryPath), priority: 3 },
+        { name: 'Route Agent', agent: new RouteAgent(memoryPath), priority: 3 },
+    ];
+
+    // Ordenar por prioridade (Inventory Agent primeiro)
+    agents.sort((a, b) => a.priority - b.priority);
+
+    // 3. Inicializar cada agente
+    for (const { name, agent } of agents) {
+        console.log(`\n${'='.repeat(60)}`);
+        console.log(`🤖 Inicializando: ${name}`);
+        console.log(`${'='.repeat(60)}\n`);
+
+        try {
+            // Cada agente executa sua tarefa de inicialização
+            const result = await agent.executeWithMemory('Inicializar memória do agente', {
+                files: [],
+                areas: ['initialization'],
+                complexity: 'low',
+            });
+
+            if (result.success) {
+                console.log(`✅ ${name} inicializado com sucesso!`);
+                if (result.details) {
+                    console.log(`   ${result.details}`);
+                }
+            } else {
+                console.log(`⚠️  ${name} teve problemas na inicialização:`);
+                console.log(`   ${result.details}`);
+            }
+        } catch (error) {
+            console.log(`❌ Erro ao inicializar ${name}:`);
+            console.log(`   ${(error as Error).message}`);
+        }
+    }
+
+    // 4. Scan completo do Inventory Agent
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('🏭 INVENTORY AGENT - Escaneando Projeto Completo');
+    console.log(`${'='.repeat(60)}\n`);
+
+    const inventoryAgent = agents[0].agent as InventoryAgent;
+
+    try {
+        const scanResult = await inventoryAgent.executeWithMemory('Escanear projeto completo', {
+            files: [],
+            areas: ['all'],
+            complexity: 'high',
+        });
+
+        if (scanResult.success) {
+            console.log('\n✅ Scan completo do projeto finalizado!');
+            console.log(`   ${scanResult.details}`);
+
+            if (scanResult.recommendations && scanResult.recommendations.length > 0) {
+                console.log('\n📊 Resumo do Inventário:');
+                scanResult.recommendations.forEach((rec) => {
+                    console.log(`   ${rec}`);
+                });
+            }
+        }
+    } catch (error) {
+        console.log(`❌ Erro no scan do projeto: ${(error as Error).message}`);
+    }
+
+    // 5. Resumo final
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('🎉 INICIALIZAÇÃO COMPLETA!');
+    console.log(`${'='.repeat(60)}\n`);
+
+    console.log('✅ Todos os agentes foram inicializados e estão prontos para trabalhar!');
+    console.log('✅ Memória inicial criada para cada agente');
+    console.log('✅ Inventário completo do projeto catalogado\n');
+
+    console.log('📚 Próximos passos:');
+    console.log('   1. Execute tarefas usando: npm run task "sua tarefa"');
+    console.log('   2. Consulte a documentação em: .agents/README.md');
+    console.log('   3. Veja o inventário em: .agents/memory/inventory-agent/inventory/\n');
+
+    console.log('🤖 Sistema de Agentes Inteligentes pronto para uso!\n');
+
+    rl.close();
+}
+
+main().catch((error) => {
+    console.error('\n❌ Erro fatal durante inicialização:', error);
+    rl.close();
+    process.exit(1);
+});

package/.agents/memory/architecture-agent/failures.json

@@ -0,0 +1 @@
+[]

package/.agents/memory/architecture-agent/learnings.json

@@ -0,0 +1 @@
+[]

package/.agents/memory/architecture-agent/specialty.md

@@ -0,0 +1,31 @@
+# Architecture Agent - Especialidade
+
+## Responsabilidades
+- Validar estrutura de arquivos
+- Garantir limite de 500 linhas por arquivo
+- Detectar duplicação de código
+- Validar separação de camadas (MVC, Clean Architecture)
+- Verificar nomenclatura consistente
+
+## Expertise
+- Design Patterns (Factory, Strategy, Observer, etc.)
+- SOLID Principles
+- Clean Architecture
+- Microservices Architecture
+- Modularização e Componentização
+- DRY (Don't Repeat Yourself)
+
+## Regras
+- Máximo 500 linhas por arquivo
+- Sem duplicação de código (DRY)
+- Separação clara de responsabilidades
+- Nomenclatura consistente (PascalCase para componentes, camelCase para funções)
+- Componentes UI não devem ter lógica de API
+- Utils devem ser independentes de UI
+
+## Tarefas Típicas
+- Validar estrutura de novos componentes
+- Detectar código duplicado
+- Sugerir refatorações
+- Validar separação de camadas
+- Revisar nomenclatura de arquivos

package/.agents/memory/architecture-agent/successes.json

@@ -0,0 +1,16 @@
+[
+  {
+    "id": "1769137691457-s1srymq3m",
+    "timestamp": "2026-01-23T03:08:11.457Z",
+    "taskDescription": "Inicializar memória do agente",
+    "context": {
+      "files": [],
+      "areas": [
+        "initialization"
+      ],
+      "complexity": "low"
+    },
+    "result": "success",
+    "details": "Arquitetura validada com sucesso"
+  }
+]

package/.agents/memory/cms-agent/failures.json

@@ -0,0 +1 @@
+[]

package/.agents/memory/cms-agent/learnings.json

@@ -0,0 +1 @@
+[]