@girardelli/architect 4.0.0 → 6.0.0

package/src/core/agent-generator/detectors/toolchain-detector.ts

@@ -0,0 +1,180 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { AnalysisReport } from '../../types/core.js';
+import { FrameworkInfo, DetectedToolchain } from '../types/stack.js';
+
+export class ToolchainDetector {
+public detectToolchain(
+    projectPath: string,
+    report: AnalysisReport,
+    primaryFw: FrameworkInfo | null,
+    allFrameworks: FrameworkInfo[],
+  ): DetectedToolchain {
+    const lang = report.projectInfo.primaryLanguages[0] || 'Unknown';
+    const hasMakefile = existsSync(join(projectPath, 'Makefile'));
+    const hasDockerCompose = existsSync(join(projectPath, 'docker-compose.yml')) || existsSync(join(projectPath, 'docker-compose.yaml'));
+
+    const hasTest = (name: string) => allFrameworks.some(f => f.name === name);
+    const hasLint = (name: string) => allFrameworks.some(f => f.name === name && f.category === 'lint');
+
+    // Python
+    if (lang === 'Python') {
+      const fwName = primaryFw?.name || 'Python';
+      const hasPytest = hasTest('pytest');
+      const hasRuff = hasLint('Ruff');
+      const hasPoetry = existsSync(join(projectPath, 'poetry.lock'));
+      const hasPipenv = existsSync(join(projectPath, 'Pipfile.lock'));
+
+      let runCmd = 'python -m main';
+      if (fwName === 'FastAPI') runCmd = 'uvicorn app.main:app --reload';
+      else if (fwName === 'Django') runCmd = 'python manage.py runserver';
+      else if (fwName === 'Flask') runCmd = 'flask run --debug';
+
+      let installCmd = 'pip install -r requirements.txt';
+      if (hasPoetry) installCmd = 'poetry install';
+      else if (hasPipenv) installCmd = 'pipenv install';
+
+      return {
+        buildCmd: hasMakefile ? 'make build' : (fwName === 'Django' ? 'python manage.py check' : 'python -m py_compile main.py'),
+        testCmd: hasPytest ? 'pytest' : 'python -m unittest discover',
+        lintCmd: hasRuff ? 'ruff check .' : (hasLint('Flake8') ? 'flake8 .' : (hasLint('Pylint') ? 'pylint src/' : 'ruff check .')),
+        runCmd,
+        coverageCmd: hasPytest ? 'pytest --cov' : 'coverage run -m pytest',
+        installCmd,
+        migrateCmd: fwName === 'Django' ? 'python manage.py migrate' : (fwName === 'FastAPI' ? 'alembic upgrade head' : null),
+        depsFile: hasPoetry ? 'pyproject.toml' : (hasPipenv ? 'Pipfile' : 'requirements.txt'),
+      };
+    }
+
+    // TypeScript / JavaScript
+    if (lang === 'TypeScript' || lang === 'JavaScript') {
+      const hasYarn = existsSync(join(projectPath, 'yarn.lock'));
+      const hasPnpm = existsSync(join(projectPath, 'pnpm-lock.yaml'));
+      const pm = hasPnpm ? 'pnpm' : (hasYarn ? 'yarn' : 'npm');
+
+      return {
+        buildCmd: `${pm} run build`,
+        testCmd: hasTest('Vitest') ? `${pm} run test` : (hasTest('Jest') ? `${pm} test` : `${pm} test`),
+        lintCmd: hasLint('Biome') ? `${pm} run lint` : (hasLint('ESLint') ? `${pm} run lint` : 'npx eslint .'),
+        runCmd: `${pm} run dev`,
+        coverageCmd: `${pm} run test -- --coverage`,
+        installCmd: `${pm} install`,
+        migrateCmd: primaryFw?.name === 'NestJS' ? 'npx typeorm migration:run' : null,
+        depsFile: 'package.json',
+      };
+    }
+
+    // Java / Kotlin
+    if (lang === 'Java' || lang === 'Kotlin') {
+      const hasMaven = existsSync(join(projectPath, 'pom.xml'));
+      const hasGradle = existsSync(join(projectPath, 'build.gradle')) || existsSync(join(projectPath, 'build.gradle.kts'));
+
+      if (hasMaven) {
+        return {
+          buildCmd: 'mvn clean package',
+          testCmd: 'mvn test',
+          lintCmd: 'mvn checkstyle:check',
+          runCmd: 'mvn spring-boot:run',
+          coverageCmd: 'mvn jacoco:report',
+          installCmd: 'mvn install',
+          migrateCmd: 'mvn flyway:migrate',
+          depsFile: 'pom.xml',
+        };
+      }
+      if (hasGradle) {
+        return {
+          buildCmd: './gradlew build',
+          testCmd: './gradlew test',
+          lintCmd: './gradlew check',
+          runCmd: './gradlew bootRun',
+          coverageCmd: './gradlew jacocoTestReport',
+          installCmd: './gradlew dependencies',
+          migrateCmd: './gradlew flywayMigrate',
+          depsFile: existsSync(join(projectPath, 'build.gradle.kts')) ? 'build.gradle.kts' : 'build.gradle',
+        };
+      }
+    }
+
+    // PHP
+    if (lang === 'PHP') {
+      return {
+        buildCmd: 'composer install --no-dev',
+        testCmd: primaryFw?.name === 'Laravel' ? 'php artisan test' : 'vendor/bin/phpunit',
+        lintCmd: 'vendor/bin/phpstan analyse',
+        runCmd: primaryFw?.name === 'Laravel' ? 'php artisan serve' : 'php -S localhost:8000',
+        coverageCmd: 'vendor/bin/phpunit --coverage-text',
+        installCmd: 'composer install',
+        migrateCmd: primaryFw?.name === 'Laravel' ? 'php artisan migrate' : null,
+        depsFile: 'composer.json',
+      };
+    }
+
+    // Go
+    if (lang === 'Go') {
+      return {
+        buildCmd: 'go build ./...',
+        testCmd: 'go test ./...',
+        lintCmd: 'golangci-lint run',
+        runCmd: 'go run .',
+        coverageCmd: 'go test -coverprofile=coverage.out ./...',
+        installCmd: 'go mod download',
+        migrateCmd: null,
+        depsFile: 'go.mod',
+      };
+    }
+
+    // Ruby
+    if (lang === 'Ruby') {
+      return {
+        buildCmd: 'bundle exec rake build',
+        testCmd: hasTest('RSpec') ? 'bundle exec rspec' : 'bundle exec rake test',
+        lintCmd: 'bundle exec rubocop',
+        runCmd: primaryFw?.name === 'Ruby on Rails' ? 'rails server' : 'ruby app.rb',
+        coverageCmd: 'bundle exec rspec --format documentation',
+        installCmd: 'bundle install',
+        migrateCmd: primaryFw?.name === 'Ruby on Rails' ? 'rails db:migrate' : null,
+        depsFile: 'Gemfile',
+      };
+    }
+
+    // Dart
+    if (lang === 'Dart') {
+      return {
+        buildCmd: 'flutter build',
+        testCmd: 'flutter test',
+        lintCmd: 'dart analyze',
+        runCmd: 'flutter run',
+        coverageCmd: 'flutter test --coverage',
+        installCmd: 'flutter pub get',
+        migrateCmd: null,
+        depsFile: 'pubspec.yaml',
+      };
+    }
+
+    // Rust
+    if (lang === 'Rust') {
+      return {
+        buildCmd: 'cargo build',
+        testCmd: 'cargo test',
+        lintCmd: 'cargo clippy',
+        runCmd: 'cargo run',
+        coverageCmd: 'cargo tarpaulin',
+        installCmd: 'cargo build',
+        migrateCmd: null,
+        depsFile: 'Cargo.toml',
+      };
+    }
+
+    // Fallback
+    return {
+      buildCmd: hasMakefile ? 'make build' : 'echo "No build command detected"',
+      testCmd: hasMakefile ? 'make test' : 'echo "No test command detected"',
+      lintCmd: hasMakefile ? 'make lint' : 'echo "No lint command detected"',
+      runCmd: hasMakefile ? 'make run' : 'echo "No run command detected"',
+      coverageCmd: 'echo "No coverage command detected"',
+      installCmd: 'echo "No install command detected"',
+      migrateCmd: null,
+      depsFile: 'unknown',
+    };
+  }
+}

package/src/{agent-generator → core/agent-generator}/domain-inferrer.ts

@@ -1,12 +1,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { AnalysisReport } from '../types.js';
-import {
-  DomainInsights,
-  BusinessEntity,
-  ComplianceRequirement,
-  ExternalIntegration,
-} from './types.js';
+import { AnalysisReport } from '../types/core.js';
+import { DomainInsights, BusinessEntity, ComplianceRequirement, ExternalIntegration } from './types/domain.js';
 
 /**
  * DomainInferrer — Analyzes project metadata, file names, module structure,
@@ -51,6 +46,16 @@ export class DomainInferrer {
         'assessment': ['quiz', 'grade', 'exam', 'prova', 'nota'],
       },
     },
+    devtools: {
+      keywords: ['analyzer', 'analysis', 'architect', 'lint', 'linter', 'ast', 'parser', 'scanner', 'refactor', 'mcp', 'cli', 'plugin', 'extension', 'sdk', 'compiler', 'transpiler', 'bundler', 'formatter', 'debugger', 'profiler', 'intelligence', 'code-review', 'anti-pattern', 'score', 'metric', 'dependency-graph'],
+      subDomains: {
+        'code-intelligence': ['analyzer', 'analysis', 'architect', 'anti-pattern', 'score', 'metric', 'intelligence', 'refactor'],
+        'mcp-server': ['mcp', 'perception', 'reasoning', 'validation', 'tool-calling'],
+        'cli-tool': ['cli', 'command', 'terminal', 'argv', 'yargs', 'commander'],
+        'ide-extension': ['extension', 'plugin', 'language-server', 'lsp', 'vscode'],
+        'build-tool': ['bundler', 'compiler', 'transpiler', 'webpack', 'esbuild', 'vite'],
+      },
+    },
     saas: {
       keywords: ['tenant', 'subscription', 'plan', 'workspace', 'organization', 'team', 'member', 'role', 'permission', 'billing', 'api-key', 'webhook', 'dashboard'],
       subDomains: {

package/src/core/agent-generator/engines/audit-engine.ts

@@ -0,0 +1,98 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { AnalysisReport } from '../../types/core.js';
+import { RefactoringPlan } from '../../types/rules.js';
+import { StackInfo } from '../types/stack.js';
+import { AgentAuditFinding } from '../types/agent.js';
+
+export class AuditEngine {
+  public auditExisting(
+    agentDir: string,
+    stack: StackInfo,
+    report: AnalysisReport,
+    plan: RefactoringPlan,
+  ): AgentAuditFinding[] {
+    const findings: AgentAuditFinding[] = [];
+
+    const checkExists = (subpath: string, category: string, desc: string): void => {
+      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` });
+      }
+    };
+
+    checkExists('INDEX.md', 'core', 'Master navigation guide');
+    checkExists('agents/AGENT-ORCHESTRATOR.md', 'agents', 'Orchestrator agent with approval gates');
+    checkExists('rules/00-general.md', 'rules', 'Golden rules and conventions');
+    checkExists('rules/01-architecture.md', 'rules', 'Layer rules, dependency direction, module patterns');
+    checkExists('rules/02-security.md', 'rules', 'OWASP, input validation, secrets management');
+    checkExists('guards/PREFLIGHT.md', 'guards', '6-phase preflight checklist');
+    checkExists('guards/QUALITY-GATES.md', 'guards', '3-level quality gates');
+    checkExists('guards/CODE-REVIEW-CHECKLIST.md', 'guards', 'Structured code review checklist');
+    checkExists('workflows/new-feature.md', 'workflows', '10-step feature workflow with approval gates');
+    checkExists('workflows/fix-bug.md', 'workflows', 'Diagnostic bug fix workflow');
+
+    checkExists('templates/C4.md', 'templates', 'C4 architecture template');
+    checkExists('templates/BDD.md', 'templates', 'BDD scenario template');
+    checkExists('templates/TDD.md', 'templates', 'TDD test template');
+    checkExists('templates/ADR.md', 'templates', 'ADR decision record template');
+    checkExists('templates/THREAT-MODEL.md', 'templates', 'STRIDE threat model template');
+
+    if (stack.hasBackend) {
+      const found = this.findAgentByRole(agentDir, 'backend');
+      if (!found) {
+        findings.push({
+          type: 'MISSING', category: 'agents',
+          file: `agents/${stack.primary.toUpperCase()}-BACKEND-DEVELOPER.md`,
+          description: `No backend developer agent for ${stack.primary}`,
+        });
+      }
+    }
+    if (stack.hasFrontend) {
+      const found = this.findAgentByRole(agentDir, 'frontend');
+      if (!found) {
+        findings.push({
+          type: 'MISSING', category: 'agents',
+          file: 'agents/FRONTEND-DEVELOPER.md',
+          description: 'No frontend developer agent',
+        });
+      }
+    }
+
+    if (plan.steps.length > 0) {
+      const found = this.findAgentByRole(agentDir, 'tech-debt');
+      if (!found) {
+        findings.push({
+          type: 'IMPROVEMENT', category: 'agents',
+          file: 'agents/TECH-DEBT-CONTROLLER.md',
+          description: `${plan.steps.length} refactoring steps found but no Tech Debt agent`,
+          suggestion: 'Create a Tech Debt Controller to track and prioritize refactoring',
+        });
+      }
+    }
+
+    if (report.score.overall < 80) {
+      findings.push({
+        type: 'IMPROVEMENT', category: 'guards',
+        file: 'guards/QUALITY-GATES.md',
+        description: `Score is ${report.score.overall}/100 — quality gates should enforce improvement`,
+        suggestion: `Set minimum score threshold to ${report.score.overall + 5} and add regression guards`,
+      });
+    }
+
+    return findings;
+  }
+
+  public findAgentByRole(agentDir: string, role: string): string | null {
+    const dir = join(agentDir, 'agents');
+    if (!existsSync(dir)) return null;
+    const files = readdirSync(dir);
+    for (const file of files) {
+      const content = readFileSync(join(dir, file), 'utf-8').toLowerCase();
+      if (content.includes(role)) return file;
+    }
+    return null;
+  }
+}

package/src/core/agent-generator/engines/context-builder.ts

@@ -0,0 +1,96 @@
+import { AnalysisReport } from '../../types/core.js';
+import { RefactoringPlan } from '../../types/rules.js';
+import { StackInfo } from '../types/stack.js';
+import { EnrichedTemplateContext } from '../types/template.js';
+import { DEFAULT_AGENT_CONFIG } from '../types/agent.js';
+import { ContextEnricher } from '../context-enricher.js';
+
+export class ContextBuilder {
+  private contextEnricher = new ContextEnricher();
+  
+  public static readonly MAX_FILE_LINES = 500;
+  public static readonly EXCLUDED_SEGMENTS = [
+    'node_modules', '/dist/', '/build/', '/coverage/',
+    '/.next/', '/venv/', '/__pycache__/', '/target/',
+  ];
+
+  public sanitizeReport(report: AnalysisReport): AnalysisReport {
+    const isProjectPath = (path: string): boolean => {
+      const normalized = path.replace(/\\/g, '/');
+      return !ContextBuilder.EXCLUDED_SEGMENTS.some(seg => normalized.includes(seg));
+    };
+
+    return {
+      ...report,
+      antiPatterns: report.antiPatterns.filter(ap => {
+        if (!isProjectPath(ap.location)) return false;
+        if (ap.affectedFiles?.some(f => !isProjectPath(f))) {
+          ap.affectedFiles = ap.affectedFiles.filter(f => isProjectPath(f));
+        }
+        return true;
+      }),
+      dependencyGraph: {
+        nodes: report.dependencyGraph.nodes.filter(n => isProjectPath(n)),
+        edges: report.dependencyGraph.edges.filter(
+          e => isProjectPath(e.from) && isProjectPath(e.to)
+        ),
+      },
+      suggestions: report.suggestions.filter(
+        s => !s.description.includes('node_modules')
+      ),
+    };
+  }
+
+  public capContent(content: string): string {
+    const lines = content.split('\n');
+    if (lines.length <= ContextBuilder.MAX_FILE_LINES) return content;
+
+    const truncated = lines.slice(0, ContextBuilder.MAX_FILE_LINES);
+    truncated.push('');
+    truncated.push('<!-- Content truncated at ' + ContextBuilder.MAX_FILE_LINES + ' lines. Run `architect agents` to regenerate. -->');
+    return truncated.join('\n');
+  }
+
+  public buildContext(report: AnalysisReport, plan: RefactoringPlan, stack: StackInfo, projectPath?: string): EnrichedTemplateContext {
+    if (projectPath) {
+      return this.contextEnricher.enrich(report, plan, stack, projectPath);
+    }
+    // Fallback to basic enriched context for backward compatibility
+    return {
+      report,
+      plan,
+      stack,
+      projectName: report.projectInfo.name || 'Project',
+      stackLabel: [...stack.languages, ...stack.frameworks].join(' + '),
+      config: DEFAULT_AGENT_CONFIG,
+      domain: {
+        domain: 'general',
+        subDomain: 'general',
+        description: '',
+        businessEntities: [],
+        compliance: [],
+        integrations: [],
+        keywords: [],
+        confidence: 0,
+      },
+      modules: [],
+      endpoints: [],
+      untestedModules: [],
+      criticalPaths: [],
+      projectDepth: 'small',
+      detectedFrameworks: [],
+      primaryFramework: null,
+      toolchain: {
+        buildCmd: 'echo "No build command detected"',
+        testCmd: 'echo "No test command detected"',
+        lintCmd: 'echo "No lint command detected"',
+        runCmd: 'echo "No run command detected"',
+        coverageCmd: 'echo "No coverage command detected"',
+        installCmd: 'echo "No install command detected"',
+        migrateCmd: null,
+        depsFile: 'unknown',
+      },
+      projectStructure: 'unknown',
+    };
+  }
+}

package/src/core/agent-generator/engines/generation-engine.ts

@@ -0,0 +1,184 @@
+import { AnalysisReport, RefactoringPlan, StackInfo, AgentAuditFinding, EnrichedTemplateContext, ContextBuilder, generateIndexMd, generateOrchestrator, generatePreflight, generateQualityGates, generateGeneralRules, generateArchitectureRules, generateSecurityRules, generateNewFeatureWorkflow, generateFixBugWorkflow, generateReviewWorkflow, generateBackendAgent, generateFrontendAgent, generateSecurityAgent, generateQAAgent, generateTechDebtAgent, generateCodeReviewChecklist, generateDatabaseAgent, generateMobileAgent, generateStackRules, getStackRuleFileName, generateC4Template, generateBddTemplate, generateTddTemplate, generateAdrTemplate, generateThreatModelTemplate, generateProjectSkills, generateArchitectIntegrationSkill, generateCIPipelineSkill, generateMonorepoGuideSkill, generatePreCommitHook, generatePrePushHook, generatePostAnalysisHook } from './generation-engine_deps.js';
+
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+
+
+
+
+
+
+
+// ── Core Templates (Enterprise-Grade) ──
+
+
+
+
+
+
+
+
+
+
+
+
+// ── Stack-Specific Templates ──
+
+
+// ── Domain Templates ──
+
+
+// ── Skills Generator ──
+
+
+// ── Hooks Generator ──
+
+
+export class GenerationEngine {
+  private contextBuilder = new ContextBuilder();
+
+  public generateFull(agentDir: string, report: AnalysisReport, plan: RefactoringPlan, stack: StackInfo, projectPath: string): string[] {
+    const generated: string[] = [];
+    const ctx = this.contextBuilder.buildContext(report, plan, stack, projectPath);
+
+    // Create directories
+    const dirs = ['agents', 'rules', 'guards', 'workflows', 'templates', 'skills', 'hooks'];
+    for (const d of dirs) mkdirSync(join(agentDir, d), { recursive: true });
+
+    // ── Core files (Enterprise-Grade) ──
+    const coreFiles: Record<string, string> = {
+      'INDEX.md': generateIndexMd(ctx),
+      'agents/AGENT-ORCHESTRATOR.md': generateOrchestrator(ctx),
+      'guards/PREFLIGHT.md': generatePreflight(ctx),
+      'guards/QUALITY-GATES.md': generateQualityGates(ctx),
+      'guards/CODE-REVIEW-CHECKLIST.md': generateCodeReviewChecklist(ctx),
+      'rules/00-general.md': generateGeneralRules(ctx),
+      'rules/01-architecture.md': generateArchitectureRules(ctx),
+      'rules/02-security.md': generateSecurityRules(ctx),
+      'workflows/new-feature.md': generateNewFeatureWorkflow(ctx),
+      'workflows/fix-bug.md': generateFixBugWorkflow(ctx),
+      'workflows/review.md': generateReviewWorkflow(ctx),
+    };
+
+    // ── Stack-specific agents ──
+    if (stack.hasBackend) {
+      coreFiles[`agents/${stack.primary.toUpperCase()}-BACKEND-DEVELOPER.md`] = generateBackendAgent(ctx);
+    }
+    if (stack.hasFrontend) {
+      const FRONTEND_FWS = ['Angular', 'Vue', 'Vue.js', 'Next.js', 'React', 'Nuxt', 'Svelte', 'Remix'];
+      const detectedFw = ctx.detectedFrameworks?.find(f => FRONTEND_FWS.includes(f.name));
+      const fwName = detectedFw?.name ||
+        stack.frameworks.find(f => FRONTEND_FWS.includes(f)) || 'Frontend';
+      coreFiles[`agents/${fwName.toUpperCase().replace('.', '').replace(/\s/g, '-')}-FRONTEND-DEVELOPER.md`] = generateFrontendAgent(ctx);
+    }
+    if (stack.hasMobile) {
+      coreFiles['agents/FLUTTER-UI-DEVELOPER.md'] = generateMobileAgent(ctx);
+    }
+    if (stack.hasDatabase) {
+      coreFiles['agents/DATABASE-ENGINEER.md'] = generateDatabaseAgent(ctx);
+    }
+    coreFiles['agents/SECURITY-AUDITOR.md'] = generateSecurityAgent(ctx);
+    coreFiles['agents/QA-TEST-ENGINEER.md'] = generateQAAgent(ctx);
+    coreFiles['agents/TECH-DEBT-CONTROLLER.md'] = generateTechDebtAgent(ctx);
+
+    // ── Stack-specific rules ──
+    const stackRuleContent = generateStackRules(ctx);
+    const stackRuleFile = getStackRuleFileName(ctx);
+    if (stackRuleContent && stackRuleFile) {
+      coreFiles[`rules/${stackRuleFile}.md`] = stackRuleContent;
+    }
+
+    // ── Domain templates ──
+    coreFiles['templates/C4.md'] = generateC4Template(ctx);
+    coreFiles['templates/BDD.md'] = generateBddTemplate(ctx);
+    coreFiles['templates/TDD.md'] = generateTddTemplate(ctx);
+    coreFiles['templates/ADR.md'] = generateAdrTemplate(ctx);
+    coreFiles['templates/THREAT-MODEL.md'] = generateThreatModelTemplate(ctx);
+
+    // ── Project Skills (padrões detectados) ──
+    const skillsContent = generateProjectSkills(ctx);
+    if (skillsContent) {
+      coreFiles['skills/PROJECT-PATTERNS.md'] = skillsContent;
+    }
+
+    // ── Data-driven Skills (real project data) ──
+    coreFiles['skills/ARCHITECT-INTEGRATION.md'] = generateArchitectIntegrationSkill(ctx);
+    coreFiles['skills/CI-PIPELINE.md'] = generateCIPipelineSkill(ctx);
+
+    const monorepoGuide = generateMonorepoGuideSkill(ctx);
+    if (monorepoGuide) {
+      coreFiles['skills/MONOREPO-GUIDE.md'] = monorepoGuide;
+    }
+
+    // ── Executable Hooks ──
+    coreFiles['hooks/pre-commit.sh'] = generatePreCommitHook(ctx);
+    coreFiles['hooks/pre-push.sh'] = generatePrePushHook(ctx);
+    coreFiles['hooks/post-analysis.sh'] = generatePostAnalysisHook(ctx);
+
+    // ── Write all files (with size cap) ──
+    for (const [path, content] of Object.entries(coreFiles)) {
+      const fullPath = join(agentDir, path);
+      const dir = join(fullPath, '..');
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      writeFileSync(fullPath, this.contextBuilder.capContent(content));
+      generated.push(path);
+    }
+
+    return generated;
+  }
+
+  public generateMissing(
+    agentDir: string,
+    audit: AgentAuditFinding[],
+    report: AnalysisReport,
+    plan: RefactoringPlan,
+    stack: StackInfo,
+    projectPath: string,
+  ): string[] {
+    const generated: string[] = [];
+    const missing = audit.filter(f => f.type === 'MISSING');
+    const ctx = this.contextBuilder.buildContext(report, plan, stack, projectPath);
+
+    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.file, ctx);
+      if (content) {
+        writeFileSync(fullPath, content);
+        generated.push(finding.file);
+      }
+    }
+
+    return generated;
+  }
+
+  public getTemplateFor(file: string, ctx: EnrichedTemplateContext): string | null {
+    if (file.includes('INDEX')) return generateIndexMd(ctx);
+    if (file.includes('ORCHESTRATOR')) return generateOrchestrator(ctx);
+    if (file.includes('PREFLIGHT')) return generatePreflight(ctx);
+    if (file.includes('QUALITY-GATES')) return generateQualityGates(ctx);
+    if (file.includes('CODE-REVIEW')) return generateCodeReviewChecklist(ctx);
+    if (file.includes('SECURITY')) return generateSecurityAgent(ctx);
+    if (file.includes('QA')) return generateQAAgent(ctx);
+    if (file.includes('TECH-DEBT')) return generateTechDebtAgent(ctx);
+    if (file.includes('BACKEND')) return generateBackendAgent(ctx);
+    if (file.includes('FRONTEND')) return generateFrontendAgent(ctx);
+    if (file.includes('FLUTTER')) return generateMobileAgent(ctx);
+    if (file.includes('DATABASE')) return generateDatabaseAgent(ctx);
+    if (file.includes('00-general')) return generateGeneralRules(ctx);
+    if (file.includes('01-architecture')) return generateArchitectureRules(ctx);
+    if (file.includes('02-security')) return generateSecurityRules(ctx);
+    if (file.includes('03-')) return generateStackRules(ctx);
+    if (file.includes('new-feature') || file.includes('develop')) return generateNewFeatureWorkflow(ctx);
+    if (file.includes('fix-bug')) return generateFixBugWorkflow(ctx);
+    if (file.includes('review')) return generateReviewWorkflow(ctx);
+    if (file.includes('C4')) return generateC4Template(ctx);
+    if (file.includes('BDD')) return generateBddTemplate(ctx);
+    if (file.includes('TDD')) return generateTddTemplate(ctx);
+    if (file.includes('ADR')) return generateAdrTemplate(ctx);
+    if (file.includes('THREAT')) return generateThreatModelTemplate(ctx);
+    return null;
+  }
+}

package/src/core/agent-generator/engines/generation-engine_deps.ts

@@ -0,0 +1,21 @@
+export { AnalysisReport } from '../../types/core.js';
+export { RefactoringPlan } from '../../types/rules.js';
+export { StackInfo } from '../types/stack.js';
+export { AgentAuditFinding } from '../types/agent.js';
+export { EnrichedTemplateContext } from '../types/template.js';
+export { ContextBuilder } from './context-builder.js';
+export { generateIndexMd } from '../templates/core/index-md.js';
+export { generateOrchestrator } from '../templates/core/orchestrator.js';
+export { generatePreflight } from '../templates/core/preflight.js';
+export { generateQualityGates } from '../templates/core/quality-gates.js';
+export { generateGeneralRules } from '../templates/core/general-rules.js';
+export { generateArchitectureRules } from '../templates/core/architecture-rules.js';
+export { generateSecurityRules } from '../templates/core/security-rules.js';
+export { generateNewFeatureWorkflow } from '../templates/core/workflow-new-feature.js';
+export { generateFixBugWorkflow } from '../templates/core/workflow-fix-bug.js';
+export { generateReviewWorkflow } from '../templates/core/workflow-review.js';
+export { generateBackendAgent, generateFrontendAgent, generateSecurityAgent, generateQAAgent, generateTechDebtAgent, generateCodeReviewChecklist, generateDatabaseAgent, generateMobileAgent } from '../templates/core/agents.js';
+export { generateStackRules, getStackRuleFileName } from '../templates/stack/index.js';
+export { generateC4Template, generateBddTemplate, generateTddTemplate, generateAdrTemplate, generateThreatModelTemplate } from '../templates/domain/index.js';
+export { generateProjectSkills, generateArchitectIntegrationSkill, generateCIPipelineSkill, generateMonorepoGuideSkill } from '../templates/core/skills-generator.js';
+export { generatePreCommitHook, generatePrePushHook, generatePostAnalysisHook } from '../templates/core/hooks-generator.js';