wegho-agentes 7.0.0 → 7.0.1

package/.agents/agents/quality/agent.ts

@@ -1,269 +0,0 @@
-/**
- * Quality Agent (com Memória)
- * 
- * Responsabilidades:
- * - Executar lint (ESLint)
- * - Executar type check (TypeScript)
- * - Executar build
- * - Executar testes
- * - Dar decisão final GO/NO-GO
- * - Aprender com falhas de build recorrentes
- */
-
-import { spawn } from 'child_process';
-import * as fs from 'fs';
-import { BaseAgent, TaskContext, TaskResult } from '../../base/base-agent.js';
-
-export interface QualityCheckResult extends TaskResult {
-    checks: {
-        lint: { passed: boolean; errors: number; warnings: number };
-        typecheck: { passed: boolean; errors: number };
-        build: { passed: boolean; error?: string };
-        tests: { passed: boolean; total: number; failed: number };
-    };
-    decision: 'GO' | 'NO-GO';
-}
-
-export class QualityAgent extends BaseAgent {
-    constructor(memoryBasePath: string = '.agents/memory') {
-        super('quality-agent', memoryBasePath);
-    }
-
-    /**
-     * Implementação da validação de qualidade
-     */
-    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
-        console.log('\n🔍 Executando validações de qualidade...\n');
-
-        const checks = {
-            lint: await this.runLint(),
-            typecheck: await this.runTypeCheck(),
-            build: await this.runBuild(),
-            tests: await this.runTests()
-        };
-
-        // Decisão GO/NO-GO
-        const decision = this.makeDecision(checks);
-
-        const success = decision === 'GO';
-        const details = this.formatChecks(checks, decision);
-
-        const issues: string[] = [];
-        if (!checks.lint.passed) issues.push(`Lint: ${checks.lint.errors} erro(s)`);
-        if (!checks.typecheck.passed) issues.push(`TypeCheck: ${checks.typecheck.errors} erro(s)`);
-        if (!checks.build.passed) issues.push('Build falhou');
-        if (!checks.tests.passed) issues.push(`Tests: ${checks.tests.failed} falhou(ram)`);
-
-        return {
-            success,
-            details,
-            issues: issues.length > 0 ? issues : undefined,
-        };
-    }
-
-    /**
-     * Executa lint
-     */
-    private async runLint(): Promise<{ passed: boolean; errors: number; warnings: number }> {
-        console.log('  📝 Executando lint...');
-
-        return new Promise((resolve) => {
-            // Verificar se package.json tem script de lint
-            if (!this.hasScript('lint')) {
-                console.log('     ⏭️  Lint não configurado');
-                resolve({ passed: true, errors: 0, warnings: 0 });
-                return;
-            }
-
-            const lint = spawn('npm', ['run', 'lint'], { shell: true });
-
-            let output = '';
-            lint.stdout.on('data', (data) => { output += data.toString(); });
-            lint.stderr.on('data', (data) => { output += data.toString(); });
-
-            lint.on('close', (code) => {
-                const errors = (output.match(/error/gi) || []).length;
-                const warnings = (output.match(/warning/gi) || []).length;
-                const passed = code === 0;
-
-                console.log(`     ${passed ? '✅' : '❌'} Lint: ${errors} erro(s), ${warnings} aviso(s)`);
-                resolve({ passed, errors, warnings });
-            });
-
-            lint.on('error', () => {
-                resolve({ passed: false, errors: 1, warnings: 0 });
-            });
-        });
-    }
-
-    /**
-     * Executa type check
-     */
-    private async runTypeCheck(): Promise<{ passed: boolean; errors: number }> {
-        console.log('  🔤 Executando type check...');
-
-        return new Promise((resolve) => {
-            const tsc = spawn('npx', ['tsc', '--noEmit'], { shell: true });
-
-            let output = '';
-            tsc.stdout.on('data', (data) => { output += data.toString(); });
-            tsc.stderr.on('data', (data) => { output += data.toString(); });
-
-            tsc.on('close', (code) => {
-                const errors = (output.match(/error TS/g) || []).length;
-                const passed = code === 0;
-
-                console.log(`     ${passed ? '✅' : '❌'} TypeCheck: ${errors} erro(s)`);
-                resolve({ passed, errors });
-            });
-
-            tsc.on('error', () => {
-                console.log('     ⏭️  TypeScript não disponível');
-                resolve({ passed: true, errors: 0 });
-            });
-        });
-    }
-
-    /**
-     * Executa build
-     */
-    private async runBuild(): Promise<{ passed: boolean; error?: string }> {
-        console.log('  🏗️  Executando build...');
-
-        return new Promise((resolve) => {
-            if (!this.hasScript('build')) {
-                console.log('     ⏭️  Build não configurado');
-                resolve({ passed: true });
-                return;
-            }
-
-            const build = spawn('npm', ['run', 'build'], { shell: true });
-
-            let output = '';
-            build.stdout.on('data', (data) => { output += data.toString(); });
-            build.stderr.on('data', (data) => { output += data.toString(); });
-
-            build.on('close', (code) => {
-                const passed = code === 0;
-                const error = passed ? undefined : output.substring(0, 500);
-
-                console.log(`     ${passed ? '✅' : '❌'} Build ${passed ? 'passou' : 'falhou'}`);
-                resolve({ passed, error });
-            });
-
-            build.on('error', () => {
-                resolve({ passed: false, error: 'Erro ao executar build' });
-            });
-        });
-    }
-
-    /**
-     * Executa testes
-     */
-    private async runTests(): Promise<{ passed: boolean; total: number; failed: number }> {
-        console.log('  🧪 Executando testes...');
-
-        return new Promise((resolve) => {
-            if (!this.hasScript('test')) {
-                console.log('     ⏭️  Testes não configurados');
-                resolve({ passed: true, total: 0, failed: 0 });
-                return;
-            }
-
-            const test = spawn('npm', ['run', 'test', '--', '--passWithNoTests'], { shell: true });
-
-            let output = '';
-            test.stdout.on('data', (data) => { output += data.toString(); });
-            test.stderr.on('data', (data) => { output += data.toString(); });
-
-            test.on('close', (code) => {
-                const passed = code === 0;
-                const total = (output.match(/Tests:.*?(\d+) total/)?.[1] || '0');
-                const failed = (output.match(/Tests:.*?(\d+) failed/)?.[1] || '0');
-
-                console.log(`     ${passed ? '✅' : '❌'} Tests: ${failed} falhou(ram) de ${total}`);
-                resolve({ passed, total: parseInt(total), failed: parseInt(failed) });
-            });
-
-            test.on('error', () => {
-                resolve({ passed: true, total: 0, failed: 0 });
-            });
-        });
-    }
-
-    /**
-     * Verifica se script existe no package.json
-     */
-    private hasScript(scriptName: string): boolean {
-        try {
-            const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
-            return !!packageJson.scripts?.[scriptName];
-        } catch {
-            return false;
-        }
-    }
-
-    /**
-     * Toma decisão GO/NO-GO
-     */
-    private makeDecision(checks: QualityCheckResult['checks']): 'GO' | 'NO-GO' {
-        // Bloqueadores: lint errors, type errors, build failed
-        if (checks.lint.errors > 0) return 'NO-GO';
-        if (checks.typecheck.errors > 0) return 'NO-GO';
-        if (!checks.build.passed) return 'NO-GO';
-        if (!checks.tests.passed) return 'NO-GO';
-
-        return 'GO';
-    }
-
-    /**
-     * Formata resultado dos checks
-     */
-    private formatChecks(checks: QualityCheckResult['checks'], decision: 'GO' | 'NO-GO'): string {
-        let details = `Decisão: ${decision}\n`;
-        details += `Lint: ${checks.lint.passed ? 'OK' : 'FALHOU'}\n`;
-        details += `TypeCheck: ${checks.typecheck.passed ? 'OK' : 'FALHOU'}\n`;
-        details += `Build: ${checks.build.passed ? 'OK' : 'FALHOU'}\n`;
-        details += `Tests: ${checks.tests.passed ? 'OK' : 'FALHOU'}`;
-        return details;
-    }
-
-    /**
-     * Especialidade padrão do Quality Agent
-     */
-    protected getDefaultSpecialty(): string {
-        return `# Quality Agent - Especialidade
-
-## Responsabilidades
-- Executar lint (ESLint)
-- Executar type check (TypeScript)
-- Executar build
-- Executar testes unitários e integração
-- Dar decisão final GO/NO-GO
-- Garantir qualidade do código
-
-## Expertise
-- Testing (Jest, Vitest, Playwright, Cypress)
-- Linting (ESLint, Prettier)
-- TypeScript
-- CI/CD
-- Code Quality Metrics
-- Test Coverage
-
-## Regras
-- Zero erros de lint (warnings são aceitáveis)
-- Zero erros de type check
-- Build deve passar
-- Todos os testes devem passar
-- Cobertura de testes > 80% (recomendado)
-
-## Tarefas Típicas
-- Validar qualidade antes de commit
-- Executar suite completa de testes
-- Dar GO/NO-GO para deploy
-- Identificar problemas de qualidade
-- Sugerir melhorias de código
-`;
-    }
-}
-

package/.agents/agents/quality/memory.md

@@ -1,110 +0,0 @@
-# Memória do Agente quality
-
-Última atualização: 2026-02-08T06:24:05Z
-
----
-
-## 📊 Estatísticas
-
-- Total de sucessos: 0
-- Total de falhas: 8
-- Taxa de sucesso: 0%
-- Aprendizados acumulados: 0
-
----
-
-## ✅ Sucessos Recentes
-_Nenhum sucesso registrado ainda._
-
----
-
-## ❌ Falhas Registradas
-
-### 25/01/2026 - `1769351012233-8iq3diadc`
-
-**Tarefa**: Tarefa falhou
-
-**Motivo**: Decisão: NO-GO
-Lint: OK
-TypeCheck: FALHOU
-Build: OK
-Tests: FALHOU
-
-**Lição aprendida**: Revisar integração com o sistema de build
-
-### 25/01/2026 - `1769351012228-znimww07t`
-
-**Tarefa**: Executar lint, typecheck, build e dar GO/NO-GO final
-
-**Motivo**: Decisão: NO-GO
-Lint: OK
-TypeCheck: FALHOU
-Build: OK
-Tests: FALHOU
-
-### 24/01/2026 - `1769269851402-qx70c6kbg`
-
-**Tarefa**: Executar lint, typecheck, build e dar GO/NO-GO final
-
-**Motivo**: Decisão: NO-GO
-Lint: OK
-TypeCheck: FALHOU
-Build: OK
-Tests: FALHOU
-
-### 24/01/2026 - `1769254256874-5hy2s1uqr`
-
-**Tarefa**: Executar lint, typecheck, build e dar GO/NO-GO final
-
-**Motivo**: Decisão: NO-GO
-Lint: OK
-TypeCheck: FALHOU
-Build: OK
-Tests: FALHOU
-
-### 24/01/2026 - `1769254251000-z0qxliysk`
-
-**Tarefa**: Executar lint, typecheck, build e dar GO/NO-GO final
-
-**Motivo**: Decisão: NO-GO
-Lint: OK
-TypeCheck: FALHOU
-Build: OK
-Tests: FALHOU
-
-### 24/01/2026 - `1769254245505-f8crsz8wr`
-
-**Tarefa**: Executar lint, typecheck, build e dar GO/NO-GO final
-
-**Motivo**: Decisão: NO-GO
-Lint: OK
-TypeCheck: FALHOU
-Build: OK
-Tests: FALHOU
-
-### 24/01/2026 - `1769252942499-4hah8cbvu`
-
-**Tarefa**: Executar lint, typecheck, build e dar GO/NO-GO final
-
-**Motivo**: Decisão: NO-GO
-Lint: OK
-TypeCheck: FALHOU
-Build: OK
-Tests: FALHOU
-
-### 23/01/2026 - `1769137692468-2vntl6niu`
-
-**Tarefa**: Inicializar memória do agente
-
-**Motivo**: Decisão: NO-GO
-Lint: OK
-TypeCheck: FALHOU
-Build: OK
-Tests: FALHOU
-
----
-
-## 🧠 Aprendizados
-
-_Nenhum aprendizado registrado ainda._
-

package/.agents/agents/quality/specialty.md

@@ -1,31 +0,0 @@
-# Quality Agent - Especialidade
-
-## Responsabilidades
-- Executar lint (ESLint)
-- Executar type check (TypeScript)
-- Executar build
-- Executar testes unitários e integração
-- Dar decisão final GO/NO-GO
-- Garantir qualidade do código
-
-## Expertise
-- Testing (Jest, Vitest, Playwright, Cypress)
-- Linting (ESLint, Prettier)
-- TypeScript
-- CI/CD
-- Code Quality Metrics
-- Test Coverage
-
-## Regras
-- Zero erros de lint (warnings são aceitáveis)
-- Zero erros de type check
-- Build deve passar
-- Todos os testes devem passar
-- Cobertura de testes > 80% (recomendado)
-
-## Tarefas Típicas
-- Validar qualidade antes de commit
-- Executar suite completa de testes
-- Dar GO/NO-GO para deploy
-- Identificar problemas de qualidade
-- Sugerir melhorias de código

package/.agents/agents/rag/README.md

@@ -1,41 +0,0 @@
-# RAG Agent
-
-## 🎯 Responsabilidade
-
-Especialista em Retrieval-Augmented Generation (RAG), busca semântica, embeddings e sistemas de conhecimento baseados em LLMs.
-
-## 🛠️ Skills Disponíveis
-
-### 🔍 RAG & Semantic Search
-
-*Skills RAG serão mapeadas quando adicionadas*
-
-#### [notebooklm](../../skills/notebooklm/)
-**Propósito**: NotebookLM integration  
-**Quando usar**: RAG com Google NotebookLM  
-
-## 📋 Tarefas Típicas
-
-- ✅ Implementar sistemas RAG
-- ✅ Configurar busca semântica
-- ✅ Criar embeddings de documentos
-- ✅ Otimizar retrieval
-- ✅ Validar qualidade de respostas
-- ✅ Integrar vector databases
-
-## 🔗 Dependências
-
-- `BaseAgent`
-- `MemorySystem`
-- `SkillManager`
-
-## 🔄 Fluxo de Trabalho
-
-1. **Consulta memória**: Busca implementações RAG similares
-2. **Carrega skills**: RAG patterns
-3. **Executa implementação**: Setup de busca semântica
-4. **Registra resultado**: Salva config em memory.md
-
-## 📊 Memória
-
-Ver [memory.md](./memory.md) para histórico de sistemas RAG implementados.

package/.agents/agents/rag/agent.ts

@@ -1,85 +0,0 @@
-import { BaseAgent, TaskContext, TaskResult } from '../../base/base-agent.js';
-import * as fs from 'fs';
-import * as path from 'path';
-
-/**
- * RAG Agent - Especialista em Retrieval-Augmented Generation
- * 
- * Responsabilidades:
- * - RAG implementation
- * - Vector databases
- * - Embedding strategies
- * - LLM integration
- * 
- * Skills: rag-implementation, rag-engineer, llm-app-patterns,
- *         langfuse, langgraph
- */
-
-export class RAGAgent extends BaseAgent {
-    private skillsPath: string;
-
-    constructor(memoryPath: string) {
-        super('rag-agent', memoryPath);
-        this.skillsPath = path.join(process.cwd(), 'skills');
-    }
-
-    async executeTask(taskDescription: string, context: TaskContext): Promise<TaskResult> {
-        console.log(`\n📚 RAG Agent analisando tarefa...\n`);
-
-        const issues: string[] = [];
-        const recommendations: string[] = [];
-
-        // Análise de RAG Implementation
-        if (taskDescription.toLowerCase().includes('rag') ||
-            taskDescription.toLowerCase().includes('retrieval')) {
-
-            recommendations.push('✅ Escolher vector database adequado (Pinecone, Weaviate, Qdrant)');
-            recommendations.push('✅ Implementar chunking strategy eficiente');
-            recommendations.push('✅ Usar embeddings de qualidade (OpenAI, Cohere)');
-            recommendations.push('✅ Implementar hybrid search (vector + keyword)');
-            recommendations.push('✅ Adicionar reranking para melhor relevância');
-        }
-
-        // Análise de Vector Database
-        if (taskDescription.toLowerCase().includes('vector') ||
-            taskDescription.toLowerCase().includes('embedding')) {
-
-            recommendations.push('✅ Definir dimensão de embeddings adequada');
-            recommendations.push('✅ Criar índices otimizados');
-            recommendations.push('✅ Implementar metadata filtering');
-            recommendations.push('✅ Usar batch operations para performance');
-        }
-
-        // Análise de LLM Integration
-        if (taskDescription.toLowerCase().includes('llm') ||
-            taskDescription.toLowerCase().includes('language model')) {
-
-            recommendations.push('✅ Implementar prompt templates');
-            recommendations.push('✅ Usar context window eficientemente');
-            recommendations.push('✅ Adicionar fallback para rate limits');
-            recommendations.push('✅ Implementar caching de respostas');
-        }
-
-        // Análise de Observability
-        if (taskDescription.toLowerCase().includes('observability') ||
-            taskDescription.toLowerCase().includes('monitoring')) {
-
-            recommendations.push('✅ Usar Langfuse para tracing');
-            recommendations.push('✅ Monitorar custos de API');
-            recommendations.push('✅ Rastrear quality metrics');
-            recommendations.push('✅ Implementar feedback loops');
-        }
-
-        const success = issues.length === 0;
-
-        return {
-            success,
-            details: success
-                ? `RAG Agent: ${recommendations.length} recomendações`
-                : `RAG Agent: ${issues.length} problemas encontrados`,
-            recommendations,
-            blockers: issues
-        };
-    }
-}
-

package/.agents/agents/rag/specialty.md

@@ -1,14 +0,0 @@
-# RAG Agent - Especialidade
-
-## Responsabilidades
-- Definir responsabilidades específicas
-
-## Expertise
-- Definir áreas de expertise
-
-## Regras
-- Arquivos < 500 linhas
-- Não alucinar APIs
-
-## Tarefas Típicas
-- Listar tarefas típicas

package/.agents/agents/security/README.md

@@ -1,152 +0,0 @@
-# Security Agent
-
-## 🎯 Responsabilidade
-
-Auditor de segurança especializado em identificar vulnerabilidades, validar implementações seguras e garantir conformidade com OWASP e melhores práticas de segurança.
-
-## 🛠️ Skills Disponíveis
-
-### 🔒 Segurança de API
-
-#### [api-security-best-practices](../../skills/api-security-best-practices/)
-**Propósito**: Melhores práticas de segurança para APIs  
-**Quando usar**: Ao auditar ou implementar APIs  
-**Capacidades**: Autenticação, autorização, rate limiting, validação
-
-#### [broken-authentication](../../skills/broken-authentication/)
-**Propósito**: Detectar falhas de autenticação  
-**Quando usar**: Auditoria de sistemas de login/auth  
-**Capacidades**: Session management, password policies, MFA
-
-### 🔐 Autenticação & Autorização
-
-#### [jwt-security](../../skills/jwt-security/)
-**Propósito**: Segurança em JWT tokens  
-**Quando usar**: Implementar/auditar JWT  
-**Capacidades**: Token validation, signing algorithms, refresh tokens
-
-#### [oauth-openid](../../skills/oauth-openid/)
-**Propósito**: OAuth 2.0 e OpenID Connect  
-**Quando usar**: Implementar autenticação federada  
-**Capacidades**: Authorization flows, scopes, PKCE
-
-### 🛡️ Proteção contra Vulnerabilidades
-
-#### [sql-injection-prevention](../../skills/sql-injection-prevention/)
-**Propósito**: Prevenir SQL Injection  
-**Quando usar**: Auditoria de queries de banco  
-**Capacidades**: Prepared statements, ORM, input sanitization
-
-#### [xss-prevention](../../skills/xss-prevention/)
-**Propósito**: Prevenir Cross-Site Scripting  
-**Quando usar**: Auditoria de input/output  
-**Capacidades**: Sanitization, CSP, encoding
-
-#### [csrf-prevention](../../skills/csrf-prevention/)
-**Propósito**: Prevenir CSRF attacks  
-**Quando usar**: Proteger formulários/mutations  
-**Capacidades**: CSRF tokens, SameSite cookies
-
-### 🗄️ Segurança de Banco de Dados
-
-#### [postgres-security](../../skills/postgres-security/)
-**Propósito**: Segurança PostgreSQL  
-**Quando usar**: Configurar/auditar banco  
-**Capacidades**: RLS, roles, encryption, auditing
-
-### 🌐 Web Security
-
-#### [security-headers](../../skills/security-headers/)
-**Propósito**: Headers de segurança HTTP  
-**Quando usar**: Configurar servidores web  
-**Capacidades**: HSTS, CSP, X-Frame-Options, CORS
-
-#### [input-validation](../../skills/input-validation/)
-**Propósito**: Validação robusta de inputs  
-**Quando usar**: Processar dados do usuário  
-**Capacidades**: Schema validation, sanitization, type checking
-
-### 📋 Frameworks & Standards
-
-#### [owasp-top-10](../../skills/owasp-top-10/)
-**Propósito**: OWASP Top 10 vulnerabilities  
-**Quando usar**: Auditoria geral de segurança  
-**Capacidades**: Checklist completo OWASP
-
-#### [secure-coding-practices](../../skills/secure-coding-practices/)
-**Propósito**: Práticas de código seguro  
-**Quando usar**: Code review, desenvolvimento  
-**Capacidades**: Input validation, error handling, secrets management
-
-### 🧪 Testing & Assessment
-
-#### [security-testing](../../skills/security-testing/)
-**Propósito**: Testes de segurança  
-**Quando usar**: Validar implementações  
-**Capacidades**: Automated scanning, manual testing
-
-#### [threat-modeling](../../skills/threat-modeling/)
-**Propósito**: Modelagem de ameaças  
-**Quando usar**: Design de sistemas  
-**Capacidades**: STRIDE, attack trees, risk assessment
-
-#### [secure-architecture](../../skills/secure-architecture/)
-**Propósito**: Arquitetura segura  
-**Quando usar**: Design de aplicações  
-**Capacidades**: Zero trust, defense in depth, least privilege
-
-#### [ethical-hacking-methodology](../../skills/ethical-hacking-methodology/)
-**Propósito**: Metodologia de hacking ético  
-**Quando usar**: Pentests estruturados  
-
-#### [cloud-penetration-testing](../../skills/cloud-penetration-testing/)
-**Propósito**: Pentest cloud geral  
-**Quando usar**: Auditar cloud (multi-provider)  
-
-#### [file-path-traversal](../../skills/file-path-traversal/)
-**Propósito**: Path traversal attacks  
-**Quando usar**: Testar vulnerabilidades de arquivo  
-
-#### [file-uploads](../../skills/file-uploads/)
-**Propósito**: Segurança de file uploads  
-**Quando usar**: Validar uploads seguros  
-
-#### [html-injection-testing](../../skills/html-injection-testing/)
-**Propósito**: Testes de HTML injection  
-**Quando usar**: Complementar XSS testing
-
-#### [idor-testing](../../skills/idor-testing/)
-**Propósito**: Insecure Direct Object Reference  
-**Quando usar**: Testar controle de acesso  
-
-#### [cc-skill-security-review](../../skills/cc-skill-security-review/)
-**Propósito**: Security code review  
-**Quando usar**: Revisar código por segurança  
-
-## 📋 Tarefas Típicas
-
-- ✅ Auditar autenticação e autorização
-- ✅ Detectar vulnerabilidades OWASP Top 10
-- ✅ Validar implementação de security headers
-- ✅ Revisar políticas de senha e MFA
-- ✅ Verificar proteção contra injection attacks
-- ✅ Auditar configurações de banco de dados
-- ✅ Validar sanitização e validação de inputs
-- ✅ Revisar gestão de tokens e sessões
-
-## 🔗 Dependências
-
-- `BaseAgent`
-- `MemorySystem`
-- `SkillManager`
-
-## 🔄 Fluxo de Trabalho
-
-1. **Consulta memória**: Busca vulnerabilidades similares já detectadas
-2. **Carrega skills**: Seleciona skills relevantes para auditoria
-3. **Executa auditoria**: Valida segurança com checklist OWASP
-4. **Registra findings**: Salva vulnerabilidades em memory.md
-
-## 📊 Memória
-
-Ver [memory.md](./memory.md) para histórico de vulnerabilidades detectadas e correções aplicadas.