@girardelli/architect 5.0.0 → 8.1.0

package/src/adapters/cli.ts

@@ -0,0 +1,492 @@
+#!/usr/bin/env node
+
+/**
+ * Architect CLI v8.1
+ * Enterprise Architecture Analysis — @girardelli/architect
+ *
+ * Uso:
+ *   npx architect analyze ./src
+ *   npx architect analyze ./src --format html --output report.html
+ *   npx architect diagram ./src
+ *   npx architect score ./src
+ *   npx architect anti-patterns ./src
+ */
+
+import { architect, ProgressEvent } from '../core/architect.js';
+import { GenesisTerminal } from '../core/GenesisTerminal.js';
+import { c, ProgressReporter } from './progress-logger.js';
+import { AgentExecutor } from '@girardelli/architect-agents/src/core/agent-runtime/executor.js';
+import { ReportGenerator } from './reporter.js';
+import { HtmlReportGenerator } from './html-reporter.js';
+import { RefactorReportGenerator } from './refactor-reporter.js';
+import { writeFileSync, existsSync,  readFileSync } from 'fs';
+import { resolve, basename,  join } from 'path';
+import { logger } from '@girardelli/architect-core/src/infrastructure/logger.js';
+import { i18n } from '@girardelli/architect-core/src/core/i18n.js';
+import * as yaml from 'yaml';
+import chokidar from 'chokidar';
+import { ArchitectRules, ValidationResult } from '@girardelli/architect-core/src/core/types/architect-rules.js';
+import { RulesEngine } from '@girardelli/architect-core/src/core/rules-engine.js';
+import { execSync } from 'child_process';
+import { GithubActionAdapter } from './github-action.js';
+import * as github from '@actions/github';
+
+type OutputFormat = 'json' | 'markdown' | 'html';
+
+interface CliOptions {
+  command: string;
+  path: string;
+  format: OutputFormat;
+  output?: string;
+  verbose: boolean;
+  locale: string;
+  watch: boolean;
+  auto: boolean;
+}
+
+
+
+// ── CLI Parsing ──
+
+
+
+function parseArgs(args: string[]): CliOptions {
+  const command = args[0] || 'analyze';
+  const pathArg = args.find((a) => !a.startsWith('--') && a !== command) || '.';
+  const formatIdx = args.indexOf('--format');
+  const format = (formatIdx >= 0 ? args[formatIdx + 1] : 'html') as OutputFormat;
+  const outputIdx = args.indexOf('--output');
+  const output = outputIdx >= 0 ? args[outputIdx + 1] : undefined;
+  const verbose = args.includes('--verbose') || args.includes('-v');
+
+  const localeIdx = args.indexOf('--locale');
+  let locale = 'en'; // default
+  if (localeIdx >= 0 && args[localeIdx + 1]) {
+    locale = args[localeIdx + 1];
+  } else {
+    // Attempt detect via ENV
+    const envLang = process.env.LANG || process.env.LANGUAGE || '';
+    if (envLang.toLowerCase().includes('pt')) {
+      locale = 'pt-BR';
+    }
+  }
+
+  const watch = args.includes('--watch') || args.includes('-w');
+  const auto = args.includes('--auto');
+
+  return { command, path: resolve(pathArg), format, output, verbose, locale, watch, auto };
+}
+
+function printUsage(): void {
+  console.log(`
+${c.cyan}${c.bold}⚡ Architect Agent v7.0${c.reset} — Enterprise Architecture Intelligence
+
+${c.bold}Usage:${c.reset}
+  architect <command> [path] [options]
+
+${c.bold}Commands:${c.reset}
+  ${c.cyan}analyze${c.reset}         Full architecture analysis (default)
+  ${c.cyan}genesis${c.reset}         [NEW] Interactive God Mode Terminal (TUI)
+  ${c.cyan}execute${c.reset}         Autonomous Agent Runtime - auto-refactor project
+  ${c.cyan}check${c.reset}           Run architecture-as-code validation against .architect.rules.yml
+  ${c.cyan}pr-review${c.reset}       Run in GitHub Actions to comment on PRs with Score Delta
+  ${c.cyan}refactor${c.reset}        Generate refactoring plan with actionable steps
+  ${c.cyan}agents${c.reset}          Generate/audit .agent/ directory with AI agents
+  ${c.cyan}diagram${c.reset}         Generate architecture diagram only
+  ${c.cyan}score${c.reset}           Calculate quality score only
+  ${c.cyan}anti-patterns${c.reset}   Detect anti-patterns only
+  ${c.cyan}layers${c.reset}          Analyze layer structure only
+
+${c.bold}Options:${c.reset}
+  --format <type>   Output format: html, json, markdown (default: html)
+  --output <file>   Output file path
+  --locale <lang>   Language (en or pt-BR)
+  --verbose, -v     Enable verbose debug logging
+  --watch, -w       Watch mode (re-run check on file changes)
+  --auto            Agent YOLO Mode - auto-approve structural changes
+  --help            Show this help message
+
+${c.bold}Examples:${c.reset}
+  ${c.dim}$${c.reset} architect execute ./src
+  ${c.dim}$${c.reset} architect execute ./src --auto
+  ${c.dim}$${c.reset} architect analyze ./src --format html --output report.html
+
+${c.dim}@girardelli/architect — Girardelli Tecnologia${c.reset}
+  `);
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+    printUsage();
+    process.exit(0);
+  }
+
+  const options = parseArgs(args);
+  logger.setup({ verbose: options.verbose, json: options.format === 'json' });
+  
+  // Set global locale
+  i18n.setLocale(options.locale as any);
+
+  try {
+    switch (options.command) {
+      case 'genesis': {
+        const terminal = new GenesisTerminal(architect);
+        await terminal.start();
+        break;
+      }
+
+      case 'analyze': {
+        const progress = new ProgressReporter();
+        progress.printHeader(options.path);
+
+        const report = await architect.analyze(options.path, (e: ProgressEvent) => progress.onProgress(e));
+
+        // Refactoring
+        progress.printExtraPhase('REFACTOR ENGINE', 'Building refactoring plan', c.orange);
+        const plan = architect.refactor(report, options.path);
+        progress.printExtraComplete(
+          `${c.white}${plan.steps.length}${c.reset}${c.dim} steps · ${c.reset}${c.white}${plan.totalOperations}${c.reset}${c.dim} operations · est. +${plan.estimatedScoreAfter.overall - plan.currentScore.overall} pts${c.reset}`
+        );
+
+        // Agent suggestion
+        progress.printExtraPhase('AGENT SYSTEM', 'Analyzing agent requirements', c.magenta);
+        const agentSuggestion = architect.suggestAgents(report, plan, options.path);
+        progress.printExtraComplete(
+          `${c.white}${agentSuggestion.suggestedAgents.length}${c.reset}${c.dim} agents suggested${agentSuggestion.hasExistingAgents ? ' (existing .agent/ audited)' : ''}${c.reset}`
+        );
+
+        const projectName = String(report.projectInfo.name || basename(options.path)).replace(/[^a-zA-Z0-9-]/g, '-');
+
+        // Report generation
+        if (options.format === 'html') {
+          progress.printExtraPhase('REPORT BUILDER', 'Generating interactive HTML report', c.cyan);
+          const htmlGenerator = new HtmlReportGenerator();
+          const html = htmlGenerator.generateHtml(report, plan, agentSuggestion);
+          const outputPath = options.output || `architect-report-${projectName}.html`;
+          writeFileSync(outputPath, html);
+          progress.printExtraComplete(`${c.green}${outputPath}${c.reset}`);
+        } else if (options.format === 'markdown') {
+          progress.printExtraPhase('REPORT BUILDER', 'Generating Markdown report', c.cyan);
+          const mdGenerator = new ReportGenerator();
+          const markdown = mdGenerator.generateMarkdownReport(report);
+          const outputPath = options.output || `architect-report-${projectName}.md`;
+          writeFileSync(outputPath, markdown);
+          progress.printExtraComplete(`${c.green}${outputPath}${c.reset}`);
+        } else {
+          progress.printExtraPhase('REPORT BUILDER', 'Generating JSON report', c.cyan);
+          const outputPath = options.output || `architect-report-${projectName}.json`;
+          writeFileSync(outputPath, JSON.stringify({ report, plan, agentSuggestion }, null, 2));
+          progress.printExtraComplete(`${c.green}${outputPath}${c.reset}`);
+        }
+
+        // Summary
+        progress.printSummary(report.score.overall, report.score.breakdown, {
+          files: report.projectInfo.totalFiles,
+          lines: report.projectInfo.totalLines,
+          antiPatterns: report.antiPatterns.length,
+          refactorSteps: plan.steps.length,
+          refactorOps: plan.totalOperations,
+          agents: agentSuggestion.suggestedAgents.length,
+        });
+        break;
+      }
+
+      case 'refactor': {
+        const progress = new ProgressReporter();
+        progress.printHeader(options.path);
+
+        const report = await architect.analyze(options.path, (e: ProgressEvent) => progress.onProgress(e));
+
+        progress.printExtraPhase('REFACTOR ENGINE', 'Building refactoring plan', c.orange);
+        const plan = architect.refactor(report, options.path);
+        const projectName = String(report.projectInfo.name || basename(options.path)).replace(/[^a-zA-Z0-9-]/g, '-');
+
+        if (options.format === 'json') {
+          const outputPath = options.output || `refactor-plan-${projectName}.json`;
+          writeFileSync(outputPath, JSON.stringify(plan, null, 2));
+          progress.printExtraComplete(`${c.green}${outputPath}${c.reset}`);
+        } else {
+          const refactorReporter = new RefactorReportGenerator();
+          const html = refactorReporter.generateHtml(plan);
+          const outputPath = options.output || `refactor-plan-${projectName}.html`;
+          writeFileSync(outputPath, html);
+          progress.printExtraComplete(`${c.green}${outputPath}${c.reset}`);
+        }
+
+        process.stderr.write(`\n  ${c.bold}REFACTORING PLAN${c.reset}\n`);
+        process.stderr.write(`  ${c.dim}Steps:${c.reset} ${c.white}${plan.steps.length}${c.reset}  ${c.dim}Ops:${c.reset} ${c.white}${plan.totalOperations}${c.reset}  ${c.dim}Tier1:${c.reset} ${c.white}${plan.tier1Steps}${c.reset}  ${c.dim}Tier2:${c.reset} ${c.white}${plan.tier2Steps}${c.reset}\n`);
+        process.stderr.write(`  ${c.dim}Score:${c.reset} ${c.white}${plan.currentScore.overall}${c.reset}${c.dim} → ${c.reset}${c.green}${plan.estimatedScoreAfter.overall}${c.reset} ${c.dim}(+${plan.estimatedScoreAfter.overall - plan.currentScore.overall})${c.reset}\n\n`);
+        break;
+      }
+
+      case 'check': {
+        const rulesPath = join(options.path, '.architect.rules.yml');
+
+        const executeCheck = async (): Promise<boolean> => {
+          if (!existsSync(rulesPath)) {
+            logger.error(`Rules file not found at: ${rulesPath}`);
+            logger.error(`Create a '.architect.rules.yml' file to use the 'check' command.`);
+            return false;
+          }
+
+          let rules: ArchitectRules;
+          try {
+            const raw = readFileSync(rulesPath, 'utf8');
+            rules = yaml.parse(raw) as ArchitectRules;
+          } catch (e: any) {
+            logger.error(`Failed to parse ${rulesPath}: ${e.message}`);
+            return false;
+          }
+
+          process.stderr.write(`\n  ${c.cyan}◉${c.reset} ${c.bold}RULES ENGINE${c.reset} ${c.dim}— Validating against .architect.rules.yml...${c.reset}\n`);
+
+          const report = await architect.analyze(options.path);
+          const engine = new RulesEngine();
+          const result = engine.validate(report, rules);
+
+          if (result.violations.length === 0) {
+            process.stderr.write(`\n  ${c.green}✓ All quality gates and boundaries passed!${c.reset} ${c.dim}(Score: ${report.score.overall}/100)${c.reset}\n\n`);
+            return true;
+          }
+
+          process.stderr.write(`\n  ${c.red}✗ Architecture validation failed!${c.reset} ${c.dim}(Score: ${report.score.overall}/100)${c.reset}\n\n`);
+
+          let errors = 0;
+          let warnings = 0;
+
+          for (const v of result.violations) {
+            if (v.level === 'error') {
+              errors++;
+              process.stderr.write(`  ${c.red}[ERROR]${c.reset} ${c.bold}${v.rule}${c.reset}: ${v.message}\n`);
+            } else {
+              warnings++;
+              process.stderr.write(`  ${c.yellow}[WARN]${c.reset} ${c.bold}${v.rule}${c.reset}: ${v.message}\n`);
+            }
+          }
+
+          process.stderr.write(`\n  ${c.dim}Total: ${errors} errors, ${warnings} warnings.${c.reset}\n\n`);
+          return result.success;
+        };
+
+        if (options.watch) {
+          process.stderr.write(`\n  ${c.dim}👀 Watch mode enabled. Listening for changes in ${options.path}...${c.reset}\n`);
+          
+          await executeCheck();
+          
+          const watcher = chokidar.watch([
+            join(options.path, '**/*.ts'),
+            join(options.path, '**/*.js'),
+            rulesPath
+          ], {
+            ignored: /(^|[\/\\])\../, // ignore dotfiles
+            persistent: true,
+            ignoreInitial: true,
+          });
+
+          watcher.on('all', async (_event, path) => {
+            console.clear();
+            process.stderr.write(`  ${c.dim}↻ File changed: ${basename(path)}. Re-running checks...${c.reset}\n`);
+            await executeCheck();
+          });
+          
+          // Keep process alive
+          return new Promise(() => {});
+        } else {
+          const success = await executeCheck();
+          if (!success) process.exit(1);
+        }
+        break;
+      }
+
+      case 'pr-review': {
+        const githubToken = process.env.GITHUB_TOKEN;
+        if (!githubToken) {
+          logger.error('GITHUB_TOKEN environment variable is required for pr-review');
+          process.exit(1);
+          return;
+        }
+
+        if (!github.context.payload.pull_request) {
+          logger.error('Not running in a Pull Request context. Exiting.');
+          process.exit(0);
+          return;
+        }
+
+        process.stderr.write(`\n  ${c.cyan}◉${c.reset} ${c.bold}PR REVIEWER${c.reset} ${c.dim}— Analyzing HEAD vs BASE...${c.reset}\n`);
+
+        const headReport = await architect.analyze(options.path);
+        
+        let baseReport = null;
+        try {
+          const baseRef = github.context.payload.pull_request.base.ref;
+          process.stderr.write(`  ${c.dim}↳ Fetching and checking out base branch: ${baseRef}${c.reset}\n`);
+          
+          execSync(`git fetch origin ${baseRef} || true`, { stdio: 'ignore', cwd: options.path });
+          const currentBranch = execSync(`git rev-parse --abbrev-ref HEAD`, { cwd: options.path }).toString().trim();
+          execSync(`git checkout ${baseRef}`, { stdio: 'ignore', cwd: options.path });
+          
+          process.stderr.write(`  ${c.dim}↳ Analyzing base branch...${c.reset}\n`);
+          baseReport = await architect.analyze(options.path);
+
+          process.stderr.write(`  ${c.dim}↳ Reverting to original branch: ${currentBranch}${c.reset}\n`);
+          execSync(`git checkout ${currentBranch}`, { stdio: 'ignore', cwd: options.path });
+        } catch (e: any) {
+          logger.error(`Failed to analyze base branch: ${e.message}`);
+          process.stderr.write(`  ${c.yellow}⚠️ Falling back to single-scan (no delta)${c.reset}\n`);
+          // Ensure we try to checkout back just in case
+          try { execSync(`git checkout -`, { stdio: 'ignore', cwd: options.path }); } catch {}
+        }
+
+        let validationResult: ValidationResult | undefined;
+        const rulesPath = join(options.path, '.architect.rules.yml');
+        if (existsSync(rulesPath)) {
+          process.stderr.write(`  ${c.dim}↳ Validating Architecture Rules...${c.reset}\n`);
+          const raw = readFileSync(rulesPath, 'utf8');
+          const rules = yaml.parse(raw) as ArchitectRules;
+          const engine = new RulesEngine();
+          validationResult = engine.validate(headReport, rules);
+        }
+
+        process.stderr.write(`  ${c.dim}↳ Posting comment to GitHub PR #${github.context.payload.pull_request.number}...${c.reset}\n`);
+        const adapter = new GithubActionAdapter(githubToken);
+        await adapter.postComment(headReport, baseReport, validationResult);
+        
+        process.stderr.write(`\n  ${c.green}✓ PR Comment successfully posted!${c.reset}\n\n`);
+
+        if (validationResult && !validationResult.success) {
+          process.stderr.write(`  ${c.red}✗ Architecture rules validation failed (Action blocked).${c.reset}\n\n`);
+          process.exit(1);
+        }
+        break;
+      }
+
+      case 'agents': {
+        const progress = new ProgressReporter();
+        progress.printHeader(options.path);
+
+        const report = await architect.analyze(options.path, (e: ProgressEvent) => progress.onProgress(e));
+
+        progress.printExtraPhase('REFACTOR ENGINE', 'Building refactoring plan', c.orange);
+        const plan = architect.refactor(report, options.path);
+        progress.printExtraComplete(`${c.white}${plan.steps.length}${c.reset}${c.dim} steps${c.reset}`);
+
+        progress.printExtraPhase('AGENT GENERATOR', 'Generating .agent/ framework', c.magenta);
+        const outputDir = options.output || undefined;
+        const result = architect.agents(report, plan, options.path, outputDir);
+        progress.printExtraComplete(`${c.white}${result.generated.length}${c.reset}${c.dim} files generated${c.reset}`);
+
+        process.stderr.write(`\n  ${c.bold}🤖 AGENT SYSTEM${c.reset}\n\n`);
+
+        if (result.generated.length > 0) {
+          process.stderr.write(`  ${c.green}Generated:${c.reset}\n`);
+          for (const file of result.generated) {
+            process.stderr.write(`  ${c.dim}  📄${c.reset} ${file}\n`);
+          }
+        }
+
+        if (result.audit.length > 0) {
+          const missing = result.audit.filter((f: any) => f.type === 'MISSING');
+          const improvements = result.audit.filter((f: any) => f.type === 'IMPROVEMENT');
+          const ok = result.audit.filter((f: any) => f.type === 'OK');
+
+          if (ok.length > 0) process.stderr.write(`\n  ${c.green}✓ ${ok.length} checks passed${c.reset}\n`);
+          if (missing.length > 0) {
+            process.stderr.write(`\n  ${c.red}✗ ${missing.length} missing (auto-generated):${c.reset}\n`);
+            for (const f of missing) process.stderr.write(`    ${c.dim}📄${c.reset} ${f.file} — ${f.description}\n`);
+          }
+          if (improvements.length > 0) {
+            process.stderr.write(`\n  ${c.yellow}💡 ${improvements.length} improvements:${c.reset}\n`);
+            for (const f of improvements) {
+              process.stderr.write(`    ${c.dim}⚡${c.reset} ${f.description}\n`);
+              if (f.suggestion) process.stderr.write(`      ${c.dim}→ ${f.suggestion}${c.reset}\n`);
+            }
+          }
+        }
+        process.stderr.write(`\n  ${c.dim}Score: ${report.score.overall}/100${c.reset}\n\n`);
+        break;
+      }
+
+      case 'execute': {
+        const progress = new ProgressReporter();
+        progress.printHeader(options.path);
+
+        const report = await architect.analyze(options.path, (e: ProgressEvent) => progress.onProgress(e));
+
+        progress.printExtraPhase('REFACTOR ENGINE', 'Building automated refactoring plan', c.orange);
+        const plan = architect.refactor(report, options.path);
+        progress.printExtraComplete(`${c.white}${plan.steps.length}${c.reset}${c.dim} steps generated${c.reset}`);
+
+        const executor = new AgentExecutor(options.auto);
+        await executor.executePlan(plan);
+        break;
+      }
+
+      case 'diagram': {
+        const diagram = await architect.diagram(options.path);
+        if (options.output) {
+          writeFileSync(options.output, diagram);
+          process.stderr.write(`  ${c.green}✓${c.reset} Diagram saved: ${options.output}\n`);
+        } else {
+          console.log(diagram);
+        }
+        break;
+      }
+
+      case 'score': {
+        const score = await architect.score(options.path);
+        if (options.format === 'json') {
+          console.log(JSON.stringify(score, null, 2));
+        } else {
+          const scoreColor = score.overall >= 80 ? c.green : score.overall >= 60 ? c.yellow : c.red;
+          process.stderr.write(`\n  ${c.bold}ARCHITECTURE SCORE${c.reset}\n`);
+          process.stderr.write(`  ${scoreColor}${c.bold}${score.overall}/100${c.reset}\n\n`);
+          for (const [name, value] of Object.entries(score.breakdown)) {
+            process.stderr.write(`  ${c.dim}${name}:${c.reset} ${c.white}${value}${c.reset}\n`);
+          }
+          process.stderr.write('\n');
+        }
+        break;
+      }
+
+      case 'anti-patterns': {
+        const patterns = await architect.antiPatterns(options.path);
+        if (options.format === 'json') {
+          console.log(JSON.stringify(patterns, null, 2));
+        } else {
+          process.stderr.write(`\n  ${c.bold}ANTI-PATTERNS${c.reset} — ${patterns.length} found\n\n`);
+          for (const p of patterns) {
+            const sevColor = p.severity === 'CRITICAL' ? c.red : p.severity === 'HIGH' ? c.orange : c.yellow;
+            process.stderr.write(`  ${sevColor}[${p.severity}]${c.reset} ${c.bold}${p.name}${c.reset}: ${p.description}\n`);
+          }
+          process.stderr.write('\n');
+        }
+        break;
+      }
+
+      case 'layers': {
+        const layers = await architect.layers(options.path);
+        if (options.format === 'json') {
+          console.log(JSON.stringify(layers, null, 2));
+        } else {
+          process.stderr.write(`\n  ${c.bold}ARCHITECTURE LAYERS${c.reset}\n\n`);
+          for (const l of layers) {
+            process.stderr.write(`  ${c.cyan}${l.name}${c.reset}: ${c.white}${l.files.length}${c.reset} files\n`);
+          }
+          process.stderr.write('\n');
+        }
+        break;
+      }
+
+      default:
+        logger.error(`Unknown command: ${options.command}`);
+        process.exit(1);
+    }
+  } catch (err: any) {
+    logger.error('Fatal execution error', err);
+    process.exit(1);
+  }
+}
+
+main();

package/src/adapters/github-action.ts

@@ -0,0 +1,109 @@
+import * as core from '@actions/core';
+import * as github from '@actions/github';
+import { AnalysisReport } from '@girardelli/architect-core/src/core/types/core.js';
+import { ValidationResult } from '@girardelli/architect-core/src/core/types/architect-rules.js';
+
+export class GithubActionAdapter {
+  private octokit: ReturnType<typeof github.getOctokit>;
+  private context = github.context;
+
+  constructor(token: string) {
+    this.octokit = github.getOctokit(token);
+  }
+
+  async postComment(
+    headReport: AnalysisReport,
+    baseReport?: AnalysisReport | null,
+    validationResult?: ValidationResult
+  ): Promise<void> {
+    if (!this.context.payload.pull_request) {
+      core.info('Not running in a Pull Request context. Skipping comment.');
+      return;
+    }
+
+    const issueNumber = this.context.payload.pull_request.number;
+    const body = this.buildMarkdownBody(headReport, baseReport, validationResult);
+
+    await this.octokit.rest.issues.createComment({
+      owner: this.context.repo.owner,
+      repo: this.context.repo.repo,
+      issue_number: issueNumber,
+      body,
+    });
+  }
+
+  private buildMarkdownBody(
+    headReport: AnalysisReport,
+    baseReport?: AnalysisReport | null,
+    validationResult?: ValidationResult
+  ): string {
+    const hScore = headReport.score.overall;
+    const bScore = baseReport ? baseReport.score.overall : null;
+
+    let deltaStr = '';
+    if (bScore !== null) {
+      const delta = hScore - bScore;
+      if (delta > 0) {
+        deltaStr = `📈 **+${delta}** (Improved from ${bScore})`;
+      } else if (delta < 0) {
+        deltaStr = `📉 **${delta}** (Regressed from ${bScore})`;
+      } else {
+        deltaStr = `➖ **0** (Stable at ${bScore})`;
+      }
+    } else {
+      deltaStr = `🆕 (First Scan)`;
+    }
+
+    let validationStr = '';
+    if (validationResult) {
+      if (validationResult.success) {
+        validationStr = `✅ **Quality Gates Passed!**`;
+      } else {
+        validationStr = `❌ **Quality Gates Failed!**\n\n`;
+        validationResult.violations.forEach(v => {
+          validationStr += `- **[${v.level.toUpperCase()}]** \`${v.rule}\`: ${v.message}\n`;
+        });
+      }
+    }
+
+    // Build anti-pattern warnings
+    const critical = headReport.antiPatterns.filter(a => a.severity === 'CRITICAL');
+    const high = headReport.antiPatterns.filter(a => a.severity === 'HIGH');
+    
+    let antiPatternsStr = ``;
+    if (critical.length > 0 || high.length > 0) {
+      antiPatternsStr = `### ⚠️ Anti-Patterns Detected\n`;
+      critical.forEach(p => {
+        antiPatternsStr += `- 🔴 **${p.name}** in \`${p.location}\`: ${p.description}\n`;
+      });
+      high.forEach(p => {
+        antiPatternsStr += `- 🟠 **${p.name}** in \`${p.location}\`: ${p.description}\n`;
+      });
+    } else {
+      antiPatternsStr = `✅ **No Critical/High Anti-Patterns!** Code is clean.\n`;
+    }
+
+    return `
+## 🏗 Architect Intelligence Report
+
+> **Architecture Score:** \`${hScore}/100\`
+> **Delta:** ${deltaStr}
+
+${validationStr}
+
+---
+### 📊 Score Breakdown
+| Metric | Score |
+| --- | --- |
+| 🧩 Modularity | ${headReport.score.breakdown.modularity} |
+| 🔗 Coupling | ${headReport.score.breakdown.coupling} |
+| 🎯 Cohesion | ${headReport.score.breakdown.cohesion} |
+| 🥞 Layering | ${headReport.score.breakdown.layering} |
+
+${antiPatternsStr}
+
+---
+*Report generated automatically by [Architect Genesis API](https://github.com/girardelli/architect).*
+    `.trim();
+  }
+}