@girardelli/architect 1.3.0 → 2.2.0

package/dist/agent-generator.js

@@ -0,0 +1,1398 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, statSync } from 'fs';
+import { join } from 'path';
+/**
+ * Agent Generator — Creates or audits .agent/ directories
+ * customized to the analyzed project's stack and architecture.
+ */
+export class AgentGenerator {
+    /**
+     * Suggest agents without writing files — for unified report.
+     */
+    suggest(report, plan, projectPath) {
+        this.report = report;
+        this.plan = plan;
+        this.stack = this.detectStack(report);
+        const agentDir = join(projectPath, '.agent');
+        const isExisting = existsSync(agentDir);
+        // Helper: scan existing files in a subdirectory
+        const existingFiles = (subdir) => {
+            const dir = join(agentDir, subdir);
+            if (!existsSync(dir))
+                return new Set();
+            return new Set(readdirSync(dir).map(f => f.replace(/\.md$/, '')));
+        };
+        // Helper: determine status for an item
+        const itemStatus = (name, existingSet, auditFindings) => {
+            // Check if a matching file exists (case-insensitive comparison)
+            const found = [...existingSet].some(e => e.toLowerCase() === name.toLowerCase());
+            if (!found)
+                return 'CREATE';
+            // Exists — check if audit flagged it for improvement
+            const hasImprovement = auditFindings.some(f => f.file.toLowerCase().includes(name.toLowerCase()) && (f.type === 'IMPROVEMENT' || f.type === 'OUTDATED'));
+            return hasImprovement ? 'MODIFY' : 'KEEP';
+        };
+        // Build suggested agents with descriptions
+        const agentDefs = [
+            { name: 'AGENT-ORCHESTRATOR', desc: 'Coordena todos os agentes, decompõe requisições e consolida entregas' },
+        ];
+        if (this.stack.hasBackend)
+            agentDefs.push({
+                name: `${this.stack.primary.toUpperCase()}-BACKEND-DEVELOPER`,
+                desc: `Especialista em arquitetura ${this.stack.primary}, APIs, serviços e lógica de negócio`,
+            });
+        if (this.stack.hasFrontend) {
+            const fw = this.stack.frameworks.find(f => ['Angular', 'Vue', 'Next.js', 'React'].includes(f)) || 'FRONTEND';
+            agentDefs.push({
+                name: `${fw.toUpperCase().replace('.', '')}-FRONTEND-DEVELOPER`,
+                desc: `Desenvolve componentes ${fw}, gerencia estado e garante UX responsiva`,
+            });
+        }
+        if (this.stack.hasMobile)
+            agentDefs.push({
+                name: 'FLUTTER-UI-DEVELOPER',
+                desc: 'Screens mobile, widgets, navegação e integração com APIs',
+            });
+        if (this.stack.hasDatabase)
+            agentDefs.push({
+                name: 'DATABASE-ENGINEER',
+                desc: 'Schema design, migrations, indexação e performance de queries',
+            });
+        agentDefs.push({ name: 'SECURITY-AUDITOR', desc: 'Análise de ameaças, compliance LGPD/OWASP e prevenção de vulnerabilidades' }, { name: 'QA-TEST-ENGINEER', desc: 'Planos de teste, cobertura mínima, BDD/TDD e testes de regressão' }, { name: 'TECH-DEBT-CONTROLLER', desc: 'Controle de débito técnico, priorização de refatorações e metas de score' });
+        const ruleDefs = [
+            { name: '00-general', desc: 'Convenções de código, nomenclatura, commits e princípios gerais' },
+            { name: '01-architecture', desc: 'Separação de camadas, dependency rules e padrões de módulo' },
+            { name: '02-security', desc: 'Sanitização de inputs, secrets management e validação de dados' },
+        ];
+        if (this.stack.hasBackend)
+            ruleDefs.push({
+                name: `03-${this.stack.primary.toLowerCase()}`,
+                desc: `Padrões específicos de ${this.stack.primary}: framework conventions e anti-patterns`,
+            });
+        const guardDefs = [
+            { name: 'PREFLIGHT', desc: 'Checklist pré-ação: branch, build, testes antes de qualquer mudança' },
+            { name: 'QUALITY-GATES', desc: 'Score mínimo, cobertura, zero warnings e critérios de merge' },
+            { name: 'CODE-REVIEW-CHECKLIST', desc: 'Pontos obrigatórios de revisão: segurança, performance, legibilidade' },
+        ];
+        const workflowDefs = [
+            { name: 'develop', desc: 'Fluxo completo: branch → mockup → spec → code → test → review → merge' },
+            { name: 'fix-bug', desc: 'Diagnóstico → reprodução → root cause → fix → teste de regressão' },
+            { name: 'review', desc: 'Code review estruturado com checklist de qualidade e segurança' },
+        ];
+        // Run audit first to inform status
+        let audit = [];
+        if (isExisting) {
+            audit = this.auditExisting(agentDir);
+        }
+        // Get existing files
+        const existingAgents = existingFiles('agents');
+        const existingRules = existingFiles('rules');
+        const existingGuards = existingFiles('guards');
+        const existingWorkflows = existingFiles('workflows');
+        const existingSkillsDir = join(agentDir, 'skills');
+        const existingSkillNames = existsSync(existingSkillsDir)
+            ? new Set(readdirSync(existingSkillsDir).filter(f => {
+                try {
+                    return statSync(join(existingSkillsDir, f)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            }))
+            : new Set();
+        // Build items with status and description
+        const suggestedAgents = agentDefs.map(({ name, desc }) => ({
+            name,
+            status: itemStatus(name, existingAgents, audit),
+            description: desc,
+        }));
+        // Detect files that exist but are NOT suggested → KEEP (custom)
+        for (const existing of existingAgents) {
+            if (!agentDefs.some(d => d.name.toLowerCase() === existing.toLowerCase())) {
+                suggestedAgents.push({ name: existing, status: 'KEEP', reason: 'Custom agent', description: 'Agente customizado do projeto' });
+            }
+        }
+        const suggestedRules = ruleDefs.map(({ name, desc }) => ({
+            name,
+            status: itemStatus(name, existingRules, audit),
+            description: desc,
+        }));
+        for (const existing of existingRules) {
+            if (!ruleDefs.some(d => d.name.toLowerCase() === existing.toLowerCase())) {
+                suggestedRules.push({ name: existing, status: 'KEEP', reason: 'Custom rule', description: 'Regra customizada do projeto' });
+            }
+        }
+        const suggestedGuards = guardDefs.map(({ name, desc }) => ({
+            name,
+            status: itemStatus(name, existingGuards, audit),
+            description: desc,
+        }));
+        const suggestedWorkflows = workflowDefs.map(({ name, desc }) => ({
+            name,
+            status: itemStatus(name, existingWorkflows, audit),
+            description: desc,
+        }));
+        for (const existing of existingWorkflows) {
+            if (!workflowDefs.some(d => d.name.toLowerCase() === existing.toLowerCase())) {
+                suggestedWorkflows.push({ name: existing, status: 'KEEP', reason: 'Custom workflow', description: 'Workflow customizado do projeto' });
+            }
+        }
+        // Skills
+        const skillEntries = [
+            { name: 'test-driven-development', source: 'anthropic/courses/test-driven-development', description: 'TDD workflow: Red → Green → Refactor', status: 'CREATE' },
+            { name: 'systematic-debugging', source: 'anthropic/courses/systematic-debugging', description: 'Structured debugging methodology', status: 'CREATE' },
+            { name: 'code-review', source: 'anthropic/courses/requesting-code-review', description: 'Code review best practices', status: 'CREATE' },
+            { name: 'security-best-practices', source: 'anthropic/courses/security-best-practices', description: 'Security patterns and vulnerability prevention', status: 'CREATE' },
+            { name: 'performance-optimization', source: 'anthropic/courses/performance-optimization', description: 'Performance analysis and optimization', status: 'CREATE' },
+            { name: 'git-workflow', source: 'anthropic/courses/git-workflow', description: 'Git branching, commits, and collaboration', status: 'CREATE' },
+        ];
+        if (this.stack.languages.includes('TypeScript') || this.stack.languages.includes('JavaScript')) {
+            skillEntries.push({ name: 'next-best-practices', source: 'vercel-labs/skills/next-best-practices', description: 'Next.js patterns and performance', status: 'CREATE' }, { name: 'api-design-principles', source: 'anthropic/courses/api-design-principles', description: 'REST/GraphQL API design', status: 'CREATE' });
+        }
+        if (this.stack.frameworks.includes('Angular') || this.stack.frameworks.includes('Vue') || this.stack.frameworks.includes('React') || this.stack.frameworks.includes('Next.js')) {
+            skillEntries.push({ name: 'frontend-design', source: 'anthropic/courses/frontend-design', description: 'Modern frontend patterns and UI/UX', status: 'CREATE' }, { name: 'web-accessibility', source: 'anthropic/courses/web-accessibility', description: 'WCAG accessibility standards', status: 'CREATE' }, { name: 'ui-ux-pro-max', source: 'anthropic/courses/ui-ux-pro-max', description: '50 styles, 21 palettes, 50 font pairings', status: 'CREATE' });
+        }
+        if (this.stack.frameworks.includes('Vue')) {
+            skillEntries.push({ name: 'vue-best-practices', source: 'anthropic/courses/vue-best-practices', description: 'Vue.js composition API and patterns', status: 'CREATE' });
+        }
+        if (this.stack.languages.includes('Dart') || this.stack.frameworks.includes('Flutter')) {
+            skillEntries.push({ name: 'flutter-animations', source: 'anthropic/courses/flutter-animations', description: 'Flutter animation patterns', status: 'CREATE' });
+        }
+        if (this.stack.languages.includes('Python')) {
+            skillEntries.push({ name: 'python-performance', source: 'anthropic/courses/python-performance-optimization', description: 'Python optimization and profiling', status: 'CREATE' });
+        }
+        if (this.stack.hasDatabase) {
+            skillEntries.push({ name: 'database-schema-design', source: 'anthropic/courses/database-schema-design', description: 'Schema design, indexing, migrations', status: 'CREATE' });
+        }
+        // Update skill status based on existing skills directory
+        for (const skill of skillEntries) {
+            if (existingSkillNames.has(skill.name)) {
+                skill.status = 'KEEP';
+            }
+        }
+        return {
+            stack: this.stack,
+            hasExistingAgents: isExisting,
+            suggestedAgents,
+            suggestedRules,
+            suggestedGuards,
+            suggestedWorkflows,
+            suggestedSkills: skillEntries,
+            audit,
+            command: `architect agents ${projectPath}`,
+        };
+    }
+    /**
+     * Main entry: generate or audit .agent/ for a project.
+     */
+    generate(report, plan, projectPath, outputDir) {
+        this.report = report;
+        this.plan = plan;
+        this.stack = this.detectStack(report);
+        const agentDir = outputDir || join(projectPath, '.agent');
+        const isExisting = existsSync(agentDir);
+        if (isExisting) {
+            const audit = this.auditExisting(agentDir);
+            const generated = this.generateMissing(agentDir, audit);
+            return { generated, audit };
+        }
+        const generated = this.generateFull(agentDir);
+        return { generated, audit: [] };
+    }
+    /**
+     * Detect technology stack from the analysis report.
+     */
+    detectStack(report) {
+        const files = report.dependencyGraph.nodes;
+        const extensions = new Set();
+        const languages = new Set();
+        const frameworks = new Set();
+        for (const file of files) {
+            const ext = file.split('.').pop()?.toLowerCase() || '';
+            extensions.add(ext);
+        }
+        // Detect languages
+        if (extensions.has('py'))
+            languages.add('Python');
+        if (extensions.has('ts') || extensions.has('tsx'))
+            languages.add('TypeScript');
+        if (extensions.has('js') || extensions.has('jsx'))
+            languages.add('JavaScript');
+        if (extensions.has('dart'))
+            languages.add('Dart');
+        if (extensions.has('go'))
+            languages.add('Go');
+        if (extensions.has('rs'))
+            languages.add('Rust');
+        if (extensions.has('java') || extensions.has('kt'))
+            languages.add('Java/Kotlin');
+        if (extensions.has('rb'))
+            languages.add('Ruby');
+        if (extensions.has('php'))
+            languages.add('PHP');
+        if (extensions.has('cs'))
+            languages.add('C#');
+        // Detect frameworks from file patterns
+        const allFiles = files.join(' ');
+        if (allFiles.includes('manage.py') || allFiles.includes('django'))
+            frameworks.add('Django');
+        if (allFiles.includes('flask') || allFiles.includes('app.py'))
+            frameworks.add('Flask');
+        if (allFiles.includes('fastapi'))
+            frameworks.add('FastAPI');
+        if (allFiles.includes('.module.ts') || allFiles.includes('nest'))
+            frameworks.add('NestJS');
+        if (allFiles.includes('.component.ts') || allFiles.includes('angular'))
+            frameworks.add('Angular');
+        if (allFiles.includes('.vue'))
+            frameworks.add('Vue');
+        if (allFiles.includes('.tsx') && allFiles.includes('next'))
+            frameworks.add('Next.js');
+        if (allFiles.includes('.dart'))
+            frameworks.add('Flutter');
+        if (allFiles.includes('go.mod'))
+            frameworks.add('Go Modules');
+        if (allFiles.includes('Cargo.toml'))
+            frameworks.add('Cargo');
+        if (allFiles.includes('pom.xml') || allFiles.includes('build.gradle'))
+            frameworks.add('Spring');
+        const primary = languages.size > 0 ? [...languages][0] : 'Unknown';
+        const hasBackend = languages.has('Python') || languages.has('TypeScript') ||
+            languages.has('Go') || languages.has('Java/Kotlin') || languages.has('Ruby') || languages.has('PHP');
+        const hasFrontend = frameworks.has('Angular') || frameworks.has('Vue') ||
+            frameworks.has('Next.js') || extensions.has('html');
+        const hasMobile = languages.has('Dart') || frameworks.has('Flutter');
+        const hasDatabase = allFiles.includes('migration') || allFiles.includes('entity') ||
+            allFiles.includes('model') || allFiles.includes('schema');
+        let testFramework = 'Jest';
+        if (languages.has('Python'))
+            testFramework = 'pytest';
+        if (languages.has('Go'))
+            testFramework = 'go test';
+        if (languages.has('Dart'))
+            testFramework = 'flutter_test';
+        let packageManager = 'npm';
+        if (languages.has('Python'))
+            packageManager = 'pip';
+        if (languages.has('Go'))
+            packageManager = 'go mod';
+        if (languages.has('Dart'))
+            packageManager = 'pub';
+        return {
+            primary, languages: [...languages], frameworks: [...frameworks],
+            hasBackend, hasFrontend, hasMobile, hasDatabase,
+            testFramework, packageManager,
+        };
+    }
+    // ── Audit Existing ──
+    auditExisting(agentDir) {
+        const findings = [];
+        const checkExists = (subpath, category, desc) => {
+            const full = join(agentDir, subpath);
+            if (!existsSync(full)) {
+                findings.push({ type: 'MISSING', category, file: subpath, description: desc });
+            }
+            else {
+                findings.push({ type: 'OK', category, file: subpath, description: `${subpath} exists` });
+            }
+        };
+        // Check required structure
+        checkExists('INDEX.md', 'core', 'Index file for agent navigation');
+        checkExists('agents/AGENT-ORCHESTRATOR.md', 'agents', 'Orchestrator agent');
+        checkExists('rules/00-general.md', 'rules', 'General rules');
+        checkExists('guards/PREFLIGHT.md', 'guards', 'Preflight checklist');
+        checkExists('workflows/develop.md', 'workflows', 'Development workflow');
+        // Check stack-specific agents
+        if (this.stack.hasBackend) {
+            const backendAgent = this.findAgentByRole(agentDir, 'backend');
+            if (!backendAgent) {
+                findings.push({
+                    type: 'MISSING', category: 'agents',
+                    file: `agents/${this.stack.primary.toUpperCase()}-BACKEND-DEVELOPER.md`,
+                    description: `No backend developer agent for ${this.stack.primary}`,
+                    suggestion: `Create a ${this.stack.primary} backend agent with patterns, conventions, and architecture rules`,
+                });
+            }
+        }
+        if (this.stack.hasFrontend) {
+            const frontAgent = this.findAgentByRole(agentDir, 'frontend');
+            if (!frontAgent) {
+                findings.push({
+                    type: 'MISSING', category: 'agents',
+                    file: 'agents/FRONTEND-DEVELOPER.md',
+                    description: 'No frontend developer agent',
+                    suggestion: `Create a frontend agent for ${this.stack.frameworks.join(', ')}`,
+                });
+            }
+        }
+        // Check for tech debt alignment
+        if (this.plan.steps.length > 0) {
+            const techDebtAgent = this.findAgentByRole(agentDir, 'tech-debt');
+            if (!techDebtAgent) {
+                findings.push({
+                    type: 'IMPROVEMENT', category: 'agents',
+                    file: 'agents/TECH-DEBT-CONTROLLER.md',
+                    description: `${this.plan.steps.length} refactoring steps found but no Tech Debt agent`,
+                    suggestion: 'Create a Tech Debt Controller with the refactoring backlog',
+                });
+            }
+        }
+        // Check quality gates match score
+        if (this.report.score.overall < 80) {
+            findings.push({
+                type: 'IMPROVEMENT', category: 'guards',
+                file: 'guards/QUALITY-GATES.md',
+                description: `Score is ${this.report.score.overall}/100 — quality gates should enforce improvement`,
+                suggestion: `Set minimum score threshold to ${this.report.score.overall + 5} and add regression guards`,
+            });
+        }
+        // Check anti-pattern rules
+        for (const ap of this.report.antiPatterns) {
+            findings.push({
+                type: 'IMPROVEMENT', category: 'rules',
+                file: `rules/anti-pattern-${ap.name.toLowerCase().replace(/\s+/g, '-')}.md`,
+                description: `Anti-pattern "${ap.name}" (${ap.severity}) detected but no prevention rule`,
+                suggestion: `Add a rule to prevent "${ap.name}" from recurring`,
+            });
+        }
+        return findings;
+    }
+    findAgentByRole(agentDir, role) {
+        const agentsDir = join(agentDir, 'agents');
+        if (!existsSync(agentsDir))
+            return null;
+        const files = readdirSync(agentsDir);
+        for (const file of files) {
+            const content = readFileSync(join(agentsDir, file), 'utf-8').toLowerCase();
+            if (content.includes(role))
+                return file;
+        }
+        return null;
+    }
+    generateMissing(agentDir, audit) {
+        const generated = [];
+        const missing = audit.filter(f => f.type === 'MISSING');
+        for (const finding of missing) {
+            const fullPath = join(agentDir, finding.file);
+            const dir = join(fullPath, '..');
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            const content = this.getTemplateFor(finding.category, finding.file);
+            if (content) {
+                writeFileSync(fullPath, content);
+                generated.push(finding.file);
+            }
+        }
+        return generated;
+    }
+    // ── Full Generation ──
+    generateFull(agentDir) {
+        const generated = [];
+        const dirs = ['agents', 'rules', 'guards', 'workflows', 'skills'];
+        for (const d of dirs)
+            mkdirSync(join(agentDir, d), { recursive: true });
+        // Core files
+        const coreFiles = {
+            'INDEX.md': this.genIndex(),
+            'AGENT-CARD-SCHEMA.md': this.genSchema(),
+            'agents/AGENT-ORCHESTRATOR.md': this.genOrchestrator(),
+            'agents/SECURITY-AUDITOR.md': this.genSecurityAgent(),
+            'agents/QA-TEST-ENGINEER.md': this.genQAAgent(),
+            'agents/TECH-DEBT-CONTROLLER.md': this.genTechDebtAgent(),
+            'rules/00-general.md': this.genGeneralRules(),
+            'rules/01-architecture.md': this.genArchitectureRules(),
+            'rules/02-security.md': this.genSecurityRules(),
+            'guards/PREFLIGHT.md': this.genPreflight(),
+            'guards/QUALITY-GATES.md': this.genQualityGates(),
+            'guards/CODE-REVIEW-CHECKLIST.md': this.genCodeReview(),
+            'workflows/develop.md': this.genDevelopWorkflow(),
+            'workflows/fix-bug.md': this.genFixBugWorkflow(),
+            'workflows/review.md': this.genReviewWorkflow(),
+        };
+        // Stack-specific agents
+        if (this.stack.hasBackend) {
+            coreFiles[`agents/${this.stack.primary.toUpperCase()}-BACKEND-DEVELOPER.md`] =
+                this.genBackendAgent();
+            coreFiles[`rules/03-${this.stack.primary.toLowerCase()}.md`] =
+                this.genStackRules();
+        }
+        if (this.stack.hasFrontend) {
+            const fwName = this.stack.frameworks.find(f => ['Angular', 'Vue', 'Next.js', 'React'].includes(f)) || 'Frontend';
+            coreFiles[`agents/${fwName.toUpperCase().replace('.', '')}-FRONTEND-DEVELOPER.md`] =
+                this.genFrontendAgent();
+        }
+        if (this.stack.hasMobile) {
+            coreFiles['agents/FLUTTER-UI-DEVELOPER.md'] = this.genMobileAgent();
+        }
+        if (this.stack.hasDatabase) {
+            coreFiles['agents/DATABASE-ENGINEER.md'] = this.genDatabaseAgent();
+        }
+        for (const [path, content] of Object.entries(coreFiles)) {
+            writeFileSync(join(agentDir, path), content);
+            generated.push(path);
+        }
+        return generated;
+    }
+    getTemplateFor(category, file) {
+        if (file.includes('ORCHESTRATOR'))
+            return this.genOrchestrator();
+        if (file.includes('SECURITY'))
+            return this.genSecurityAgent();
+        if (file.includes('QA'))
+            return this.genQAAgent();
+        if (file.includes('TECH-DEBT'))
+            return this.genTechDebtAgent();
+        if (file.includes('BACKEND'))
+            return this.genBackendAgent();
+        if (file.includes('FRONTEND'))
+            return this.genFrontendAgent();
+        if (file.includes('INDEX'))
+            return this.genIndex();
+        if (file.includes('00-general'))
+            return this.genGeneralRules();
+        if (file.includes('PREFLIGHT'))
+            return this.genPreflight();
+        if (file.includes('develop'))
+            return this.genDevelopWorkflow();
+        return null;
+    }
+    // ── Template Generators ──
+    get projectName() {
+        return this.report.projectInfo.name || 'Project';
+    }
+    get stackLabel() {
+        return [
+            ...this.stack.languages,
+            ...this.stack.frameworks,
+        ].join(' + ');
+    }
+    genIndex() {
+        const agents = [
+            'AGENT-ORCHESTRATOR',
+            ...(this.stack.hasBackend ? [`${this.stack.primary.toUpperCase()}-BACKEND-DEVELOPER`] : []),
+            ...(this.stack.hasFrontend ? ['FRONTEND-DEVELOPER'] : []),
+            ...(this.stack.hasMobile ? ['FLUTTER-UI-DEVELOPER'] : []),
+            ...(this.stack.hasDatabase ? ['DATABASE-ENGINEER'] : []),
+            'SECURITY-AUDITOR',
+            'QA-TEST-ENGINEER',
+            'TECH-DEBT-CONTROLLER',
+        ];
+        return `# ${this.projectName} — Agent Framework
+
+> **Auto-generated by [Architect v2.1](https://github.com/camilooscargbaptista/architect)**
+> Stack: **${this.stackLabel}** | Score: **${this.report.score.overall}/100**
+
+---
+
+## 🔴 Leitura Obrigatória
+
+| # | Arquivo | Propósito |
+|---|---------|-----------|
+| 1 | [00-general.md](./rules/00-general.md) | Regras gerais do projeto |
+| 2 | [PREFLIGHT.md](./guards/PREFLIGHT.md) | Checklist pré-ação |
+| 3 | [QUALITY-GATES.md](./guards/QUALITY-GATES.md) | Critérios mínimos |
+
+## 🤖 Agentes Disponíveis
+
+| Agente | Arquivo | Role |
+|--------|---------|------|
+${agents.map(a => `| ${a} | [${a}.md](./agents/${a}.md) | ${a.includes('ORCHESTRATOR') ? 'coordination' : a.includes('SECURITY') || a.includes('QA') ? 'quality' : 'development'} |`).join('\n')}
+
+## 📁 Estrutura
+
+\`\`\`
+.agent/
+├── agents/      → Agentes especializados
+├── rules/       → Regras de codificação
+├── guards/      → Checklists e quality gates
+├── workflows/   → Fluxos de trabalho
+└── skills/      → Padrões e referências
+\`\`\`
+
+---
+
+**⚠️ REGRA DE OURO: Na dúvida, PARA e PERGUNTA.**
+`;
+    }
+    genSchema() {
+        return `---
+description: 'Schema de referência para Agent Cards — padrão A2A-inspired'
+version: 1.0.0
+---
+
+# Agent Card Schema
+
+> Cada agente DEVE ter um bloco \`agent_card\` no frontmatter YAML.
+
+## Schema
+
+\`\`\`yaml
+agent_card:
+  id: "string"               # kebab-case unique ID
+  name: "string"              # Human readable name
+  role: "enum"                # coordination | development | quality | protection | governance
+  capabilities: []            # List of skills
+  inputs: []                  # What the agent needs
+  outputs: []                 # What the agent produces
+  depends_on: []              # Agents that must run before
+\`\`\`
+
+## Roles
+
+| Role | Description |
+|------|-------------|
+| coordination | Orchestrates other agents |
+| development | Writes production code |
+| quality | Testing and QA |
+| protection | Security and compliance |
+| governance | Standards and tech debt |
+`;
+    }
+    genOrchestrator() {
+        const layers = this.report.layers.map(l => l.name).join(', ');
+        const antiPatterns = this.report.antiPatterns.map(a => a.name).join(', ') || 'None detected';
+        return `---
+antigravity:
+  trigger: 'always_on'
+  globs: ['**/*']
+  description: 'META-AGENT ORQUESTRADOR — Coordena todos os agentes para ${this.projectName}'
+  priority: CRITICAL
+agent_card:
+  id: 'orchestrator'
+  name: 'Agent Orchestrator'
+  role: 'coordination'
+  capabilities: [request-decomposition, agent-dispatch, plan-consolidation, quality-verification]
+  inputs: [user-story, feature-request, bug-report, refactoring-request]
+  outputs: [consolidated-plan, implementation-blocks, effort-estimate]
+  depends_on: []
+version: 1.0.0
+---
+
+# 🎭 AGENT-ORCHESTRATOR: ${this.projectName}
+
+> **Centro de comando.** Toda requisição passa por aqui.
+
+## Contexto do Projeto
+
+- **Projeto:** ${this.projectName}
+- **Stack:** ${this.stackLabel}
+- **Score Atual:** ${this.report.score.overall}/100
+- **Camadas:** ${layers}
+- **Anti-Patterns:** ${antiPatterns}
+- **Arquivos:** ${this.report.projectInfo.totalFiles} files, ${this.report.projectInfo.totalLines} lines
+
+## Missão
+
+\`\`\`
+RECEBER REQUISIÇÃO
+    ↓
+ENTENDER CONTEXTO
+    ↓
+DISPARAR AGENTES (paralelo)
+    ↓
+CONSOLIDAR ANÁLISES
+    ↓
+APRESENTAR PLANO
+    ↓
+AGUARDAR APROVAÇÃO
+    ↓
+DELEGAR IMPLEMENTAÇÃO
+    ↓
+VERIFICAR QUALIDADE
+\`\`\`
+
+## Protocolo de Recepção
+
+### FASE 0: Parsing da Requisição
+
+\`\`\`
+✓ Nome da feature/fix: _______________
+✓ Tipo: [ ] Feature  [ ] Bug Fix  [ ] Refactoring  [ ] Documentation
+✓ Camadas tocadas: ${layers}
+✓ Complexidade: [ ] XS  [ ] S  [ ] M  [ ] L  [ ] XL
+✓ Assunções (listar): _______________
+\`\`\`
+
+### FASE 1: Disparo de Agentes
+
+\`\`\`
+ORQUESTRADOR analisa requisição
+    │
+${this.stack.hasBackend ? `    ├──→ [${this.stack.primary.toUpperCase()}-BACKEND]\n    │    • Arquitetura de serviços\n    │    • API contracts\n    │    • Lógica de negócio\n    │\n` : ''}${this.stack.hasFrontend ? `    ├──→ [FRONTEND-DEVELOPER]\n    │    • Componentes e páginas\n    │    • State management\n    │    • UX/UI\n    │\n` : ''}${this.stack.hasMobile ? `    ├──→ [FLUTTER-UI-DEVELOPER]\n    │    • Screens mobile\n    │    • Navigation\n    │    • Widgets\n    │\n` : ''}${this.stack.hasDatabase ? `    ├──→ [DATABASE-ENGINEER]\n    │    • Schema design\n    │    • Migrations\n    │    • Performance\n    │\n` : ''}    ├──→ [SECURITY-AUDITOR]
+    │    • Análise de ameaças
+    │    • Compliance check
+    │
+    ├──→ [QA-TEST-ENGINEER]
+    │    • Test plan
+    │    • Coverage targets
+    │
+    └──→ [TECH-DEBT-CONTROLLER]
+         • Débito técnico existente
+         • Refatorações pré-requisito
+\`\`\`
+
+### FASE 2: Consolidação
+
+O orquestrador consolida em um plano com:
+- Diagrama de arquitetura
+- Cenários BDD
+- Plano de testes
+- Estimativa de esforço
+- Riscos e mitigações
+
+### FASE 3: Implementação
+
+Após \`/approved\`, delegar em blocos ordenados por dependência.
+
+---
+
+## Quality Gates
+
+\`\`\`
+□ Testes passando
+□ Build compilando
+□ Score >= ${Math.max(this.report.score.overall, 70)}/100
+□ Sem regressão de score
+□ Code review aprovado
+\`\`\`
+
+---
+
+**Gerado por Architect v2.1 · Score: ${this.report.score.overall}/100**
+`;
+    }
+    genBackendAgent() {
+        const lang = this.stack.primary;
+        const fw = this.stack.frameworks.filter(f => ['Django', 'Flask', 'FastAPI', 'NestJS', 'Spring', 'Express'].includes(f)).join(', ') || lang;
+        return `---
+antigravity:
+  trigger: 'on_demand'
+  globs: ['**/*.${lang === 'Python' ? 'py' : 'ts'}']
+  description: '${lang} Backend Developer — Arquitetura, APIs, serviços'
+agent_card:
+  id: '${lang.toLowerCase()}-backend'
+  name: '${lang} Backend Developer'
+  role: 'development'
+  capabilities: [api-design, service-architecture, business-logic, data-modeling]
+  inputs: [user-story, api-contracts, business-rules]
+  outputs: [controllers, services, entities, migrations, tests]
+  depends_on: [${this.stack.hasDatabase ? 'database-engineer' : ''}]
+---
+
+# 🔧 ${lang.toUpperCase()} BACKEND DEVELOPER
+
+> Especialista em backend ${fw} para ${this.projectName}
+
+## Stack
+
+- **Linguagem:** ${lang}
+- **Framework:** ${fw}
+- **Teste:** ${this.stack.testFramework}
+- **Package Manager:** ${this.stack.packageManager}
+
+## Princípios
+
+1. **SOLID** — Single Responsibility, Open/Closed, Liskov, Interface Segregation, Dependency Inversion
+2. **Clean Architecture** — Separação de camadas
+3. **DRY** — Don't Repeat Yourself
+4. **KISS** — Keep It Simple
+5. **Fail Fast** — Validação na entrada
+
+## Padrões de Código
+
+### Estrutura de Módulo
+
+\`\`\`
+src/modules/[nome]/
+├── [nome].module.${lang === 'Python' ? 'py' : 'ts'}
+├── [nome].controller.${lang === 'Python' ? 'py' : 'ts'}
+├── [nome].service.${lang === 'Python' ? 'py' : 'ts'}
+├── dto/
+├── entities/
+└── __tests__/
+\`\`\`
+
+### Convenções
+
+| Item | Padrão | Exemplo |
+|------|--------|---------|
+| Classes | PascalCase | \`UserService\` |
+| Funções | camelCase / snake_case | \`get_user\` / \`getUser\` |
+| Constantes | UPPER_SNAKE | \`MAX_RETRIES\` |
+| Arquivos | kebab-case | \`user-service.${lang === 'Python' ? 'py' : 'ts'}\` |
+
+## Checklist por Entrega
+
+\`\`\`
+□ Tipos/interfaces definidos
+□ Validação de entrada implementada
+□ Erros tratados com mensagens claras
+□ Testes unitários (mínimo 60%)
+□ Sem secrets hardcoded
+□ Logging adequado
+□ Documentação de API
+\`\`\`
+
+---
+
+**Gerado por Architect v2.1 · Score: ${this.report.score.overall}/100**
+`;
+    }
+    genFrontendAgent() {
+        const fw = this.stack.frameworks.find(f => ['Angular', 'Vue', 'Next.js', 'React'].includes(f)) || 'Frontend';
+        return `---
+antigravity:
+  trigger: 'on_demand'
+  globs: ['src/**/*.{ts,tsx,vue,html,css}']
+  description: '${fw} Frontend Developer — Componentes, páginas, UX'
+agent_card:
+  id: 'frontend-developer'
+  name: '${fw} Frontend Developer'
+  role: 'development'
+  capabilities: [component-design, state-management, responsive-ui, accessibility]
+  inputs: [mockups, api-contracts, user-stories]
+  outputs: [components, pages, services, styles, tests]
+  depends_on: ['${this.stack.primary.toLowerCase()}-backend']
+---
+
+# 🎨 ${fw.toUpperCase()} FRONTEND DEVELOPER
+
+> Especialista em frontend ${fw} para ${this.projectName}
+
+## Princípios
+
+1. **Component-Driven** — Componentes reutilizáveis
+2. **Responsive First** — Mobile-first design
+3. **Accessibility** — WCAG 2.1 AA compliance
+4. **Performance** — Lazy loading, tree shaking
+
+## Checklist
+
+\`\`\`
+□ Mockup HTML aprovado ANTES de codar
+□ Componentes reutilizáveis
+□ Estado gerenciado corretamente
+□ Responsivo testado (mobile/tablet/desktop)
+□ Loading states implementados
+□ Error states implementados
+□ Acessibilidade verificada
+□ Performance otimizada
+\`\`\`
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genMobileAgent() {
+        return `---
+antigravity:
+  trigger: 'on_demand'
+  globs: ['lib/**/*.dart']
+  description: 'Flutter UI Developer — Screens, widgets, navigation'
+agent_card:
+  id: 'flutter-ui'
+  name: 'Flutter UI Developer'
+  role: 'development'
+  capabilities: [screen-design, widget-composition, navigation, state-management]
+  inputs: [mockups, api-contracts]
+  outputs: [screens, widgets, blocs, tests]
+  depends_on: ['${this.stack.primary.toLowerCase()}-backend']
+---
+
+# 📱 FLUTTER UI DEVELOPER
+
+> Especialista em mobile Flutter para ${this.projectName}
+
+## Padrões
+
+- **State:** BLoC / Provider
+- **Navigation:** GoRouter / Navigator 2.0
+- **Architecture:** Clean Architecture
+- **Tests:** flutter_test + integration_test
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genDatabaseAgent() {
+        return `---
+antigravity:
+  trigger: 'on_demand'
+  globs: ['**/migrations/**', '**/entities/**', '**/models/**']
+  description: 'Database Engineer — Schema, migrations, performance'
+agent_card:
+  id: 'database-engineer'
+  name: 'Database Engineer'
+  role: 'development'
+  capabilities: [schema-design, migrations, indexing, query-optimization]
+  inputs: [business-rules, data-requirements]
+  outputs: [migrations, entities, indexes, constraints]
+  depends_on: []
+---
+
+# 🗄️ DATABASE ENGINEER
+
+> Especialista em banco de dados para ${this.projectName}
+
+## Regras
+
+1. **NUNCA** usar DELETE físico — sempre soft delete
+2. **SEMPRE** criar migration SQL (não ORM auto-generate)
+3. **SEMPRE** adicionar indexes para FKs e campos de busca
+4. **SEMPRE** validar constraints antes de deploy
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genSecurityAgent() {
+        return `---
+antigravity:
+  trigger: 'on_demand'
+  globs: ['**/*']
+  description: 'Security Auditor — Análise de vulnerabilidades e compliance'
+agent_card:
+  id: 'security-auditor'
+  name: 'Security Auditor'
+  role: 'protection'
+  capabilities: [threat-modeling, vulnerability-scan, compliance-check, auth-review]
+  inputs: [source-code, api-contracts, deployment-config]
+  outputs: [security-reports, threat-models, compliance-checklists]
+  depends_on: []
+---
+
+# 🛡️ SECURITY AUDITOR
+
+> Proteção contra ameaças para ${this.projectName}
+
+## Checklist de Segurança
+
+\`\`\`
+□ Sem secrets/credentials hardcoded
+□ Sem logging de dados sensíveis (passwords, tokens, PII)
+□ Inputs sanitizados
+□ Queries parametrizadas (anti SQL injection)
+□ Autenticação validada em todas as rotas
+□ Autorização (RBAC) verificada
+□ Rate limiting configurado
+□ CORS configurado corretamente
+□ Headers de segurança (HSTS, CSP, X-Frame)
+□ Dependências sem vulnerabilidades conhecidas
+\`\`\`
+
+## STRIDE Threat Model
+
+| Ameaça | Descrição | Mitigação |
+|--------|-----------|-----------|
+| **S**poofing | Falsificação de identidade | JWT + MFA |
+| **T**ampering | Alteração de dados | Validação + Checksums |
+| **R**epudiation | Negação de ações | Audit logs |
+| **I**nformation Disclosure | Vazamento de dados | Encryption + RBAC |
+| **D**enial of Service | Indisponibilidade | Rate limiting + WAF |
+| **E**levation of Privilege | Escalação de permissões | RBAC + Least privilege |
+
+---
+
+**Gerado por Architect v2.1 · Score: ${this.report.score.overall}/100**
+`;
+    }
+    genQAAgent() {
+        return `---
+antigravity:
+  trigger: 'on_demand'
+  globs: ['**/*.{test,spec}.*', '**/__tests__/**']
+  description: 'QA Test Engineer — Testes, cobertura, qualidade'
+agent_card:
+  id: 'qa-test-engineer'
+  name: 'QA Test Engineer'
+  role: 'quality'
+  capabilities: [bdd-specs, unit-tests, integration-tests, e2e-tests, coverage-analysis]
+  inputs: [user-stories, api-contracts, business-rules]
+  outputs: [test-suites, bdd-scenarios, coverage-reports]
+  depends_on: []
+---
+
+# 🧪 QA TEST ENGINEER
+
+> Qualidade e testes para ${this.projectName}
+
+## Stack de Testes
+
+- **Framework:** ${this.stack.testFramework}
+- **Cobertura mínima:** 60%
+- **Padrão:** TDD (Red → Green → Refactor)
+
+## Fluxo TDD
+
+\`\`\`
+1. RED    → Escrever teste que FALHA
+2. GREEN  → Código MÍNIMO para passar
+3. REFACTOR → Limpar sem quebrar
+\`\`\`
+
+## Cenários Obrigatórios
+
+\`\`\`
+□ Happy path (fluxo principal)
+□ Validação de entrada (dados inválidos)
+□ Edge cases (limites, null, empty)
+□ Erro handling (exceptions, timeouts)
+□ Permissões (autorizado vs não autorizado)
+□ Fluxos existentes NÃO quebrados
+\`\`\`
+
+## Padrão BDD
+
+\`\`\`gherkin
+Feature: [Nome]
+  Scenario: [Happy Path]
+    Given [contexto]
+    When [ação]
+    Then [resultado esperado]
+
+  Scenario: [Erro]
+    Given [contexto]
+    When [ação inválida]
+    Then [erro esperado]
+\`\`\`
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genTechDebtAgent() {
+        const steps = this.plan.steps.map(s => `| ${s.priority} | ${s.title} | ${s.operations.length} ops |`).join('\n');
+        return `---
+antigravity:
+  trigger: 'on_demand'
+  globs: ['**/*']
+  description: 'Tech Debt Controller — Identifica e prioriza débito técnico'
+agent_card:
+  id: 'tech-debt-controller'
+  name: 'Tech Debt Controller'
+  role: 'governance'
+  capabilities: [debt-identification, refactoring-planning, pattern-enforcement]
+  inputs: [architecture-report, anti-patterns, code-metrics]
+  outputs: [debt-backlog, refactoring-plans, improvement-metrics]
+  depends_on: []
+---
+
+# 📊 TECH DEBT CONTROLLER
+
+> Governança de débito técnico para ${this.projectName}
+
+## Estado Atual
+
+- **Score:** ${this.report.score.overall}/100
+- **Anti-patterns:** ${this.report.antiPatterns.length}
+- **Refactoring steps:** ${this.plan.steps.length}
+
+## Backlog de Refactoring
+
+| Prioridade | Item | Operações |
+|------------|------|-----------|
+${steps || '| — | Nenhum item pendente | — |'}
+
+## Taxonomia de Dívida
+
+| Tipo | Descrição | Impacto |
+|------|-----------|---------|
+| Architecture | Violações de camadas, hubs | Score |
+| Code Quality | Complexidade, duplicação | Manutenção |
+| Testing | Cobertura baixa, sem testes | Confiabilidade |
+| Security | Vulnerabilidades conhecidas | Risco |
+| Documentation | Docs ausentes ou desatualizados | Onboarding |
+
+---
+
+**Gerado por Architect v2.1 · Score: ${this.report.score.overall}/100**
+`;
+    }
+    genGeneralRules() {
+        return `---
+antigravity:
+  trigger: 'always_on'
+  globs: ['**/*']
+  description: 'Regras gerais obrigatórias — ${this.projectName}'
+---
+
+# ${this.projectName} — Regras Gerais
+
+> **LEIA TUDO ANTES DE QUALQUER AÇÃO.**
+
+## 🥇 REGRAS DE OURO (INVIOLÁVEIS)
+
+\`\`\`
+🥇 1. GIT FLOW COMPLETO
+   → Verificar branch + status ANTES de tudo
+   → feature/* → develop → staging → main
+   → NUNCA codificar direto em main/staging/develop
+
+🥇 2. DIAGNÓSTICO ANTES DE CODAR
+   → Ler código existente ANTES de implementar
+   → Verificar se já existe algo similar
+
+🥇 3. TDD
+   → Testes ANTES do código
+   → Red → Green → Refactor
+
+🥇 4. NÃO DECIDIR SOZINHO
+   → Dúvida? PARAR E PERGUNTAR
+
+🥇 5. QUALIDADE > VELOCIDADE
+   → Nunca atalhos. Fazer certo da primeira vez.
+\`\`\`
+
+## Stack
+
+| Camada | Tecnologia |
+|--------|------------|
+${this.stack.languages.map(l => `| ${l} | ${this.stack.frameworks.filter(f => f).join(', ') || l} |`).join('\n')}
+
+## Convenções de Idioma
+
+| Contexto | Idioma |
+|----------|--------|
+| Código (variáveis, funções) | Inglês |
+| Comentários | Português (Brasil) |
+| Git commits | Inglês (Conventional Commits) |
+| Documentação | Português (Brasil) |
+
+## Nomenclatura
+
+| Tipo | Padrão | Exemplo |
+|------|--------|---------|
+| Classes | PascalCase | \`UserService\` |
+| Funções | camelCase | \`getUser\` |
+| Constantes | UPPER_SNAKE | \`MAX_RETRIES\` |
+| Arquivos | kebab-case | \`user-service.ts\` |
+
+## ⛔ O QUE NUNCA FAZER
+
+\`\`\`
+❌ Commitar em main/staging/develop
+❌ Pular Git Flow
+❌ Assumir — VERIFICAR
+❌ Dizer "pronto" sem testes
+❌ Hardcoded secrets
+\`\`\`
+
+---
+
+**Gerado por Architect v2.1 · Score: ${this.report.score.overall}/100**
+`;
+    }
+    genArchitectureRules() {
+        const layers = this.report.layers.map(l => `| ${l.name} | ${l.files.length} files | ${l.description} |`).join('\n');
+        return `---
+antigravity:
+  trigger: 'always_on'
+  globs: ['**/*']
+  description: 'Regras de arquitetura — ${this.projectName}'
+---
+
+# Regras de Arquitetura
+
+## Camadas Detectadas
+
+| Camada | Arquivos | Descrição |
+|--------|----------|-----------|
+${layers}
+
+## Score Atual: ${this.report.score.overall}/100
+
+| Métrica | Valor |
+|---------|-------|
+| Modularity | ${this.report.score.breakdown.modularity} |
+| Coupling | ${this.report.score.breakdown.coupling} |
+| Cohesion | ${this.report.score.breakdown.cohesion} |
+| Layering | ${this.report.score.breakdown.layering} |
+
+## Regras
+
+1. **Respeitar camadas** — Nunca importar de camada superior
+2. **Máximo 5 dependências** — Acima disso, considerar split
+3. **Sem imports circulares** — Sempre unidirecional
+4. **Um propósito por arquivo** — Single Responsibility
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genSecurityRules() {
+        return `---
+antigravity:
+  trigger: 'always_on'
+  globs: ['**/*']
+  description: 'Regras de segurança — ${this.projectName}'
+---
+
+# Regras de Segurança
+
+## NUNCA (Zero Tolerância)
+
+\`\`\`
+❌ Hardcoded secrets, API keys, passwords
+❌ Logging de dados sensíveis (PII, tokens)
+❌ SQL sem parameterização
+❌ eval() ou exec() com input do usuário
+❌ Endpoints sem autenticação
+❌ CORS com wildcard (*) em produção
+\`\`\`
+
+## SEMPRE
+
+\`\`\`
+✅ Sanitizar inputs do usuário
+✅ Usar queries parametrizadas
+✅ Validar file uploads (tipo, tamanho)
+✅ Rate limiting em APIs públicas
+✅ Headers de segurança (HSTS, CSP)
+✅ Audit logs para ações sensíveis
+\`\`\`
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genStackRules() {
+        const lang = this.stack.primary;
+        return `---
+antigravity:
+  trigger: 'on_demand'
+  globs: ['**/*.${lang === 'Python' ? 'py' : lang === 'TypeScript' ? 'ts' : lang.toLowerCase()}']
+  description: 'Regras específicas de ${lang} — ${this.projectName}'
+---
+
+# Regras ${lang}
+
+## Boas Práticas
+
+${lang === 'Python' ? `
+- Type hints em TODAS as funções
+- Docstrings em classes e funções públicas
+- PEP 8 compliance
+- Use \`pathlib\` ao invés de \`os.path\`
+- Use \`dataclasses\` ou \`pydantic\` para modelos
+- Virtual environment obrigatório
+` : lang === 'TypeScript' ? `
+- Strict mode ativado
+- Interfaces para TODOS os contratos
+- Sem \`any\` (use \`unknown\` se necessário)
+- Async/await ao invés de callbacks
+- Enum ao invés de magic strings
+- JSDoc em funções públicas
+` : `
+- Siga as convenções da linguagem
+- Documentação obrigatória
+- Testes unitários mínimo 60%
+`}
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genPreflight() {
+        return `# PREFLIGHT Checklist — ${this.projectName}
+
+> **Execute ANTES de qualquer tarefa. Sem exceções.**
+
+## 🔴 Fase 0: Preparação
+
+\`\`\`
+□ Li e entendi a tarefa completamente?
+□ Sei qual é o objetivo?
+□ Identifiquei o tipo: [ ] Backend  [ ] Frontend  [ ] Database  [ ] Bug Fix  [ ] Feature
+\`\`\`
+
+## 🔴 Fase 1: Ambiente
+
+\`\`\`
+□ Qual branch estou?     → git branch --show-current
+□ É main ou develop?     → CRIAR BRANCH IMEDIATAMENTE
+□ Branch atualizada?     → git pull origin develop
+\`\`\`
+
+## 🔴 Fase 2: Diagnóstico
+
+\`\`\`
+□ Verifiquei código existente similar?
+□ Entendi a arquitetura afetada?
+□ Li lessons-learned (se existir)?
+\`\`\`
+
+## ⚠️ Red Flags - PARE
+
+| Red Flag | Ação |
+|----------|------|
+| Não sei onde fica o código | Pesquisar ANTES |
+| Vou assumir algo | PERGUNTAR |
+| Estou em main/develop | CRIAR BRANCH |
+| "Acho que funciona" | TESTAR |
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genQualityGates() {
+        const minScore = Math.max(this.report.score.overall - 5, 60);
+        return `# Quality Gates — ${this.projectName}
+
+> Score atual: **${this.report.score.overall}/100**
+
+## Gates Obrigatórios
+
+| Gate | Critério | Status |
+|------|----------|--------|
+| Build | Compila sem erros | ✅ Required |
+| Lint | Sem erros de lint | ✅ Required |
+| Tests | Todos passando | ✅ Required |
+| Coverage | >= 60% | ✅ Required |
+| Score | >= ${minScore}/100 | ✅ Required |
+| No Regression | Score não pode cair | ⚠️ Warning |
+
+## Métricas Atuais
+
+| Métrica | Valor | Meta |
+|---------|-------|------|
+| Modularity | ${this.report.score.breakdown.modularity} | >= 80 |
+| Coupling | ${this.report.score.breakdown.coupling} | >= 70 |
+| Cohesion | ${this.report.score.breakdown.cohesion} | >= 80 |
+| Layering | ${this.report.score.breakdown.layering} | >= 80 |
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genCodeReview() {
+        return `# Code Review Checklist — ${this.projectName}
+
+## Funcionalidade
+\`\`\`
+□ Resolve o problema descrito?
+□ Edge cases tratados?
+□ Erros tratados com mensagens claras?
+\`\`\`
+
+## Qualidade
+\`\`\`
+□ Código legível e bem nomeado?
+□ Sem duplicação desnecessária?
+□ Princípios SOLID respeitados?
+□ Complexidade controlada?
+\`\`\`
+
+## Segurança
+\`\`\`
+□ Sem secrets hardcoded?
+□ Inputs validados?
+□ Queries parametrizadas?
+\`\`\`
+
+## Testes
+\`\`\`
+□ Testes unitários adicionados?
+□ Cenários de erro testados?
+□ Cobertura >= 60%?
+\`\`\`
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genDevelopWorkflow() {
+        return `---
+name: develop
+description: Fluxo completo de desenvolvimento — ${this.projectName}
+---
+
+# Workflow: Desenvolvimento Completo
+
+## 🎯 FLUXO OBRIGATÓRIO
+
+\`\`\`
+0️⃣  GIT FLOW      → Criar feature branch
+1️⃣  ENTENDIMENTO  → Perguntas de clarificação
+2️⃣  DIAGNÓSTICO   → Verificar código existente
+3️⃣  BDD           → Cenários Gherkin (APROVAÇÃO)
+4️⃣  TDD RED       → Testes falhando
+5️⃣  TDD GREEN     → Código mínimo
+6️⃣  REFACTOR      → Código limpo
+7️⃣  GIT COMMIT    → Conventional Commits + Push
+\`\`\`
+
+## Pontos de Aprovação
+
+1. Após entendimento
+2. Após cenários BDD
+3. Após testes verdes
+4. Após refatoração
+5. Após commit e push
+
+## 🚫 PROIBIDO
+
+- ❌ Trabalhar direto em develop/main
+- ❌ Código antes de teste
+- ❌ Avançar sem aprovação
+- ❌ Commit sem Conventional Commits
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genFixBugWorkflow() {
+        return `---
+name: fix-bug
+description: Corrigir bug com diagnóstico completo — ${this.projectName}
+---
+
+# Workflow: Fix Bug
+
+\`\`\`
+1️⃣  Criar branch fix/nome-do-bug
+2️⃣  Reproduzir o bug
+3️⃣  Escrever teste que FALHA reproduzindo o bug
+4️⃣  Corrigir o código mínimo
+5️⃣  Teste passa (GREEN)
+6️⃣  Verificar que não quebrou nada
+7️⃣  Commit: fix(scope): description
+\`\`\`
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+    genReviewWorkflow() {
+        return `---
+name: review
+description: Code review completo — ${this.projectName}
+---
+
+# Workflow: Code Review
+
+\`\`\`
+1️⃣  Ler a descrição do PR
+2️⃣  Verificar diff por arquivo
+3️⃣  Executar checklist de review
+4️⃣  Rodar testes localmente
+5️⃣  Aprovar ou solicitar mudanças
+\`\`\`
+
+---
+
+**Gerado por Architect v2.1**
+`;
+    }
+}
+//# sourceMappingURL=agent-generator.js.map