wegho-agentes 4.0.1

package/.agents/core/workflow-validator.ts

@@ -0,0 +1,158 @@
+/**
+ * Workflow Validator - Garante que agentes sigam os 6 passos obrigatórios
+ * 
+ * Passos obrigatórios do AGENT_WORKFLOW.md:
+ * 1. Consultar memória para casos similares
+ * 2. Obter recomendações de aprendizados
+ * 3. Consultar repositórios de referência relevantes
+ * 4. Aplicar aprendizados com alta confiança (>0.7)
+ * 5. Registrar resultado (sucesso ou falha)
+ * 6. Gerar aprendizados baseado em feedback (opcional)
+ */
+
+export interface WorkflowStep {
+    name: string;
+    required: boolean;
+    completed: boolean;
+    timestamp?: Date;
+    details?: any;
+}
+
+export interface WorkflowValidationResult {
+    compliant: boolean;
+    missingSteps: string[];
+    warnings: string[];
+    completedSteps: string[];
+    totalRequired: number;
+    totalCompleted: number;
+}
+
+export class WorkflowValidator {
+    /**
+     * Valida se um agente seguiu todos os passos obrigatórios
+     */
+    validateAgentExecution(agentName: string, executionLog: WorkflowStep[]): WorkflowValidationResult {
+        const requiredSteps = executionLog.filter(step => step.required);
+        const completedRequired = requiredSteps.filter(step => step.completed);
+        const missingSteps = requiredSteps
+            .filter(step => !step.completed)
+            .map(step => step.name);
+
+        const warnings: string[] = [];
+        const completedSteps = executionLog
+            .filter(step => step.completed)
+            .map(step => step.name);
+
+        // Verificar se passos foram executados na ordem correta
+        const expectedOrder = [
+            'Consultar Memória',
+            'Obter Recomendações',
+            'Consultar Repositórios',
+            'Aplicar Aprendizados',
+            'Registrar Resultado'
+        ];
+
+        const completedOrder = executionLog
+            .filter(step => step.completed && step.timestamp)
+            .sort((a, b) => a.timestamp!.getTime() - b.timestamp!.getTime())
+            .map(step => step.name);
+
+        // Verificar ordem (warning, não erro)
+        for (let i = 0; i < completedOrder.length - 1; i++) {
+            const currentIndex = expectedOrder.indexOf(completedOrder[i]);
+            const nextIndex = expectedOrder.indexOf(completedOrder[i + 1]);
+
+            if (currentIndex !== -1 && nextIndex !== -1 && currentIndex > nextIndex) {
+                warnings.push(
+                    `Passos executados fora de ordem: "${completedOrder[i]}" antes de "${completedOrder[i + 1]}"`
+                );
+            }
+        }
+
+        // Verificar se passos críticos foram pulados
+        const criticalSteps = ['Consultar Memória', 'Registrar Resultado'];
+        const missingCritical = criticalSteps.filter(
+            step => !completedSteps.includes(step)
+        );
+
+        if (missingCritical.length > 0) {
+            warnings.push(
+                `Passos críticos não executados: ${missingCritical.join(', ')}`
+            );
+        }
+
+        const compliant = missingSteps.length === 0;
+
+        return {
+            compliant,
+            missingSteps,
+            warnings,
+            completedSteps,
+            totalRequired: requiredSteps.length,
+            totalCompleted: completedRequired.length
+        };
+    }
+
+    /**
+     * Gera relatório detalhado de validação
+     */
+    generateValidationReport(agentName: string, validation: WorkflowValidationResult): string {
+        const lines: string[] = [];
+
+        lines.push(`\n━━━ Validação de Workflow: ${agentName} ━━━`);
+        lines.push(`Status: ${validation.compliant ? '✅ COMPLIANT' : '❌ NON-COMPLIANT'}`);
+        lines.push(`Passos Completados: ${validation.totalCompleted}/${validation.totalRequired}`);
+
+        if (validation.completedSteps.length > 0) {
+            lines.push(`\n✅ Passos Executados:`);
+            validation.completedSteps.forEach(step => {
+                lines.push(`   - ${step}`);
+            });
+        }
+
+        if (validation.missingSteps.length > 0) {
+            lines.push(`\n❌ Passos Faltantes:`);
+            validation.missingSteps.forEach(step => {
+                lines.push(`   - ${step}`);
+            });
+        }
+
+        if (validation.warnings.length > 0) {
+            lines.push(`\n⚠️  Avisos:`);
+            validation.warnings.forEach(warning => {
+                lines.push(`   - ${warning}`);
+            });
+        }
+
+        lines.push(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
+
+        return lines.join('\n');
+    }
+
+    /**
+     * Valida múltiplos agentes e retorna resumo
+     */
+    validateMultipleAgents(
+        agentExecutions: Array<{ agentName: string; steps: WorkflowStep[] }>
+    ): {
+        allCompliant: boolean;
+        compliantCount: number;
+        nonCompliantCount: number;
+        details: Array<{ agentName: string; validation: WorkflowValidationResult }>;
+    } {
+        const details = agentExecutions.map(({ agentName, steps }) => ({
+            agentName,
+            validation: this.validateAgentExecution(agentName, steps)
+        }));
+
+        const compliantCount = details.filter(d => d.validation.compliant).length;
+        const nonCompliantCount = details.length - compliantCount;
+
+        return {
+            allCompliant: nonCompliantCount === 0,
+            compliantCount,
+            nonCompliantCount,
+            details
+        };
+    }
+}

package/.agents/domains/README.md

@@ -0,0 +1,53 @@
+# Agentes de Domínio
+
+Agentes especializados para diferentes domínios de negócio.
+
+---
+
+## 📰 News Domain (Site de Notícias)
+
+### ✅ Implementados:
+- **cms-agent.ts** - Validação de artigos/posts
+- **seo-agent.ts** - Meta tags, structured data, sitemap
+
+### 🚧 Pendentes:
+- **content-agent.ts** - Qualidade de conteúdo, links quebrados
+- **analytics-agent.ts** - Métricas, dashboards, A/B tests
+
+---
+
+## 🏭 Production Domain (Produção/Expedição)
+
+### ✅ Implementados:
+- **production-control-agent.ts** - Eventos, gargalos, fluxo
+
+### 🚧 Pendentes:
+- **quality-control-agent.ts** - Inspeções, não-conformidade
+- **shipping-agent.ts** - Pedidos expedidos, fretes
+- **inventory-agent.ts** - Estoque, níveis críticos
+
+---
+
+## 🚚 Logistics Domain (Logística)
+
+### ✅ Implementados:
+- **route-agent.ts** - Rotas, distâncias, otimização
+
+### 🚧 Pendentes:
+- **fleet-agent.ts** - Frota, manutenção, documentos
+- **warehouse-agent.ts** - Armazéns, picking, packing
+- **tracking-agent.ts** - Rastreamento GPS em tempo real
+
+---
+
+## 🔧 Como Adicionar Novo Agente
+
+1. Crie arquivo em `.agents/domains/{dominio}/{nome}-agent.ts`
+2. Implemente interface padrão com métodos `validate*`
+3. Adicione testes em `.agents/domains/{dominio}/tests/`
+4. Documente no README.md do domínio
+
+---
+
+**Status**: 5/12 implementados (42%)  
+**Última atualização**: 2026-01-20

package/.agents/domains/logistics/route-agent.ts

@@ -0,0 +1,177 @@
+/**
+ * Route Agent (com Memória)
+ * Domínio: Logística
+ * 
+ * Responsabilidades:
+ * - Otimizar rotas de entrega
+ * - Calcular distâncias e tempo estimado
+ * - Validar waypoints e sequência
+ * - Sugerir rotas eficientes
+ * - Aprender padrões de rotas otimizadas
+ */
+
+import { BaseAgent, TaskContext, TaskResult } from '../../core/base-agent';
+
+export interface Waypoint {
+    lat: number;
+    lng: number;
+    address: string;
+    order: number;
+}
+
+export interface Route {
+    id: string;
+    name: string;
+    waypoints: Waypoint[];
+    totalDistance?: number; // em km
+    estimatedDuration?: number; // em minutos
+}
+
+export class RouteAgent extends BaseAgent {
+    constructor(memoryBasePath: string = '.agents/memory') {
+        super('route-agent', memoryBasePath);
+    }
+
+    /**
+     * Implementação da otimização de rotas
+     */
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        const warnings: string[] = [];
+        const recommendations: string[] = [];
+
+        // Aqui seria feita a otimização real de rotas
+        const success = warnings.length === 0;
+        const details = success
+            ? 'Rotas otimizadas com sucesso'
+            : `Avisos: ${warnings.join(', ')}`;
+
+        return {
+            success,
+            details,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            recommendations: recommendations.length > 0 ? recommendations : undefined
+        };
+    }
+
+    /**
+     * Valida rota
+     */
+    validateRoute(route: Partial<Route>): { valid: boolean; errors: string[]; warnings: string[] } {
+        const errors: string[] = [];
+        const warnings: string[] = [];
+
+        if (!route.name || route.name.trim().length === 0) {
+            errors.push('Nome da rota é obrigatório');
+        }
+
+        if (!route.waypoints || route.waypoints.length === 0) {
+            errors.push('Rota deve ter pelo menos um waypoint');
+        } else if (route.waypoints.length === 1) {
+            warnings.push('Rota com apenas um waypoint (considere adicionar mais paradas)');
+        }
+
+        // Validar coordenadas
+        route.waypoints?.forEach((wp, index) => {
+            if (wp.lat < -90 || wp.lat > 90) {
+                errors.push(`Waypoint ${index + 1}: Latitude inválida (${wp.lat})`);
+            }
+            if (wp.lng < -180 || wp.lng > 180) {
+                errors.push(`Waypoint ${index + 1}: Longitude inválida (${wp.lng})`);
+            }
+            if (!wp.address || wp.address.trim().length === 0) {
+                warnings.push(`Waypoint ${index + 1}: Endereço vazio`);
+            }
+        });
+
+        // Validar ordem sequencial
+        const orders = route.waypoints?.map(wp => wp.order).sort((a, b) => a - b) || [];
+        const expectedOrders = Array.from({ length: orders.length }, (_, i) => i + 1);
+        if (JSON.stringify(orders) !== JSON.stringify(expectedOrders)) {
+            warnings.push('Ordem dos waypoints não é sequencial (1, 2, 3...)');
+        }
+
+        return { valid: errors.length === 0, errors, warnings };
+    }
+
+    /**
+     * Calcula distância aproximada entre dois pontos (Haversine)
+     */
+    calculateDistance(lat1: number, lng1: number, lat2: number, lng2: number): number {
+        const R = 6371; // Raio da Terra em km
+        const dLat = this.deg2rad(lat2 - lat1);
+        const dLng = this.deg2rad(lng2 - lng1);
+
+        const a =
+            Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+            Math.cos(this.deg2rad(lat1)) *
+            Math.cos(this.deg2rad(lat2)) *
+            Math.sin(dLng / 2) *
+            Math.sin(dLng / 2);
+
+        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        return R * c; // Distância em km
+    }
+
+    private deg2rad(deg: number): number {
+        return deg * (Math.PI / 180);
+    }
+
+    /**
+     * Estima distância total da rota
+     */
+    estimateTotalDistance(waypoints: Waypoint[]): number {
+        if (waypoints.length < 2) return 0;
+
+        let totalDistance = 0;
+        for (let i = 0; i < waypoints.length - 1; i++) {
+            const wp1 = waypoints[i];
+            const wp2 = waypoints[i + 1];
+            totalDistance += this.calculateDistance(wp1.lat, wp1.lng, wp2.lat, wp2.lng);
+        }
+
+        return Math.round(totalDistance * 10) / 10; // Arredondar para 1 casa decimal
+    }
+
+    /**
+     * Estima duração (assumindo velocidade média de 50 km/h)
+     */
+    estimateDuration(distanceKm: number, avgSpeedKmH: number = 50): number {
+        return Math.round((distanceKm / avgSpeedKmH) * 60); // Retorna em minutos
+    }
+
+    /**
+     * Especialidade padrão do Route Agent
+     */
+    protected getDefaultSpecialty(): string {
+        return `# Route Agent - Especialidade
+
+## Responsabilidades
+- Otimizar rotas de entrega
+- Calcular distâncias e tempo estimado
+- Validar waypoints e sequência
+- Sugerir rotas eficientes
+- Minimizar tempo e custo de transporte
+
+## Expertise
+- Otimização de Rotas
+- Algoritmos de Roteamento (TSP, VRP)
+- Cálculo de Distâncias (Haversine)
+- Logística de Transporte
+- Google Maps API / Mapbox
+
+## Regras
+- Waypoints devem ter coordenadas válidas
+- Ordem deve ser sequencial
+- Minimizar distância total
+- Considerar restrições de tempo
+- Validar endereços
+
+## Tarefas Típicas
+- Otimizar sequência de entregas
+- Calcular distância total de rota
+- Estimar tempo de viagem
+- Validar coordenadas GPS
+- Sugerir rotas alternativas
+`;
+    }
+}

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

@@ -0,0 +1,158 @@
+/**
+ * CMS Agent (com Memória)
+ * Domínio: Site de Notícias
+ * 
+ * Responsabilidades:
+ * - Validar estrutura de artigos/posts
+ * - Verificar campos obrigatórios (título, slug, conteúdo, autor)
+ * - Sugerir taxonomia (categorias, tags)
+ * - Validar schema do Supabase
+ * - Aprender padrões de conteúdo que funcionam
+ */
+
+import { BaseAgent, TaskContext, TaskResult } from '../../core/base-agent';
+
+export interface Article {
+    id: string;
+    title: string;
+    slug: string;
+    content: string;
+    author_id: string;
+    published_at: string | null;
+    category_id: string;
+    tags: string[];
+}
+
+export class CMSAgent extends BaseAgent {
+    constructor(memoryBasePath: string = '.agents/memory') {
+        super('cms-agent', memoryBasePath);
+    }
+
+    /**
+     * Implementação da validação de CMS
+     */
+    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
+        const issues: string[] = [];
+        const recommendations: string[] = [];
+
+        // Aqui seria feita a validação real de artigos
+        // Por enquanto, retorna sucesso
+        const success = issues.length === 0;
+        const details = success
+            ? 'Estrutura de CMS validada com sucesso'
+            : `Problemas encontrados: ${issues.join(', ')}`;
+
+        return {
+            success,
+            details,
+            issues: issues.length > 0 ? issues : undefined,
+            recommendations: recommendations.length > 0 ? recommendations : undefined
+        };
+    }
+
+    /**
+     * Valida estrutura de artigo
+     */
+    validateArticle(article: Partial<Article>): { valid: boolean; errors: string[] } {
+        const errors: string[] = [];
+
+        if (!article.title || article.title.trim().length === 0) {
+            errors.push('Título é obrigatório');
+        }
+
+        if (!article.slug || article.slug.trim().length === 0) {
+            errors.push('Slug é obrigatório');
+        } else if (!/^[a-z0-9-]+$/.test(article.slug)) {
+            errors.push('Slug deve conter apenas letras minúsculas, números e hífens');
+        }
+
+        if (!article.content || article.content.trim().length === 0) {
+            errors.push('Conteúdo é obrigatório');
+        }
+
+        if (!article.author_id) {
+            errors.push('Autor é obrigatório');
+        }
+
+        if (!article.category_id) {
+            errors.push('Categoria é obrigatória');
+        }
+
+        return { valid: errors.length === 0, errors };
+    }
+
+    /**
+     * Gera slug a partir do título
+     */
+    generateSlug(title: string): string {
+        return title
+            .toLowerCase()
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '') // Remove acentos
+            .replace(/[^a-z0-9\s-]/g, '') // Remove caracteres especiais
+            .trim()
+            .replace(/\s+/g, '-') // Substitui espaços por hífens
+            .replace(/-+/g, '-'); // Remove hífens duplicados
+    }
+
+    /**
+     * Valida schema Supabase para CMS
+     */
+    validateSchema(migrations: string[]): { valid: boolean; recommendations: string[] } {
+        const recommendations: string[] = [];
+        const hasArticlesTable = migrations.some(m => m.includes('create table articles'));
+        const hasCategoriesTable = migrations.some(m => m.includes('create table categories'));
+        const hasTagsTable = migrations.some(m => m.includes('create table tags'));
+
+        if (!hasArticlesTable) {
+            recommendations.push('Criar tabela "articles" (id, title, slug, content, author_id, published_at, category_id)');
+        }
+
+        if (!hasCategoriesTable) {
+            recommendations.push('Criar tabela "categories" (id, name, slug)');
+        }
+
+        if (!hasTagsTable) {
+            recommendations.push('Criar tabela "tags" (id, name) e tabela de relacionamento "article_tags"');
+        }
+
+        return { valid: recommendations.length === 0, recommendations };
+    }
+
+    /**
+     * Especialidade padrão do CMS Agent
+     */
+    protected getDefaultSpecialty(): string {
+        return `# CMS Agent - Especialidade
+
+## Responsabilidades
+- Validar estrutura de artigos/posts
+- Verificar campos obrigatórios (título, slug, conteúdo, autor)
+- Sugerir taxonomia (categorias, tags)
+- Validar schema do Supabase para CMS
+- Gerar slugs automaticamente
+
+## Expertise
+- Content Management Systems
+- Taxonomia (categorias, tags)
+- Schema de banco de dados para CMS
+- SEO-friendly URLs (slugs)
+- Estrutura de artigos/posts
+
+## Regras
+- Título é obrigatório
+- Slug deve ser único e SEO-friendly
+- Conteúdo não pode estar vazio
+- Autor deve estar vinculado
+- Categoria é obrigatória
+- Tags são opcionais mas recomendadas
+
+## Tarefas Típicas
+- Validar estrutura de novos artigos
+- Gerar slugs a partir de títulos
+- Sugerir categorias e tags
+- Validar schema de banco de dados
+- Recomendar melhorias de taxonomia
+`;
+    }
+}