@girardelli/architect 1.1.0

package/src/cli.ts

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+
+/**
+ * Architect CLI
+ * Executa análise arquitetural e gera relatórios em múltiplos formatos
+ *
+ * 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
+ *   npx architect layers ./src
+ */
+
+import { architect } from './index.js';
+import { ReportGenerator } from './reporter.js';
+import { HtmlReportGenerator } from './html-reporter.js';
+import { writeFileSync } from 'fs';
+import { resolve, basename } from 'path';
+
+type OutputFormat = 'json' | 'markdown' | 'html';
+
+interface CliOptions {
+  command: string;
+  path: string;
+  format: OutputFormat;
+  output?: string;
+}
+
+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;
+
+  return { command, path: resolve(pathArg), format, output };
+}
+
+function printUsage(): void {
+  console.log(`
+🏗️  Architect — AI-powered architecture analysis
+
+Usage:
+  architect <command> [path] [options]
+
+Commands:
+  analyze         Full architecture analysis (default)
+  diagram         Generate architecture diagram only
+  score           Calculate quality score only
+  anti-patterns   Detect anti-patterns only
+  layers          Analyze layer structure only
+
+Options:
+  --format <type>   Output format: html, json, markdown (default: html)
+  --output <file>   Output file path (default: architect-report.<ext>)
+  --help            Show this help message
+
+Examples:
+  architect analyze ./src
+  architect analyze ./src --format html --output report.html
+  architect score ./src --format json
+  architect anti-patterns ./backend/src
+  `);
+}
+
+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);
+
+  console.log('🏗️  Architect — Architecture Analysis');
+  console.log(`📂 Path: ${options.path}`);
+  console.log(`📋 Command: ${options.command}`);
+  console.log(`📄 Format: ${options.format}\n`);
+
+  try {
+    switch (options.command) {
+      case 'analyze': {
+        const report = await architect.analyze(options.path);
+        const projectName = report.projectInfo.name || basename(options.path);
+
+        if (options.format === 'html') {
+          const htmlGenerator = new HtmlReportGenerator();
+          const html = htmlGenerator.generateHtml(report);
+          const outputPath = options.output || `architect-report-${projectName}.html`;
+          writeFileSync(outputPath, html);
+          console.log(`✅ HTML report saved to: ${outputPath}`);
+          console.log(`📊 Score: ${report.score.overall}/100`);
+          console.log(`⚠️  Anti-patterns: ${report.antiPatterns.length}`);
+        } else if (options.format === 'markdown') {
+          const mdGenerator = new ReportGenerator();
+          const markdown = mdGenerator.generateMarkdownReport(report);
+          const outputPath = options.output || `architect-report-${projectName}.md`;
+          writeFileSync(outputPath, markdown);
+          console.log(`✅ Markdown report saved to: ${outputPath}`);
+        } else {
+          const outputPath = options.output || `architect-report-${projectName}.json`;
+          writeFileSync(outputPath, JSON.stringify(report, null, 2));
+          console.log(`✅ JSON report saved to: ${outputPath}`);
+        }
+
+        // Print summary to console
+        console.log(`\n═══════════════════════════════════════`);
+        console.log(`  SCORE: ${report.score.overall}/100`);
+        console.log(`═══════════════════════════════════════`);
+        console.log(`├─ Modularity: ${report.score.breakdown.modularity}`);
+        console.log(`├─ Coupling:   ${report.score.breakdown.coupling}`);
+        console.log(`├─ Cohesion:   ${report.score.breakdown.cohesion}`);
+        console.log(`└─ Layering:   ${report.score.breakdown.layering}`);
+        console.log(`\n📁 Files: ${report.projectInfo.totalFiles} | 📝 Lines: ${report.projectInfo.totalLines.toLocaleString()}`);
+        console.log(`⚠️  Anti-patterns: ${report.antiPatterns.length}`);
+        break;
+      }
+
+      case 'diagram': {
+        const diagram = await architect.diagram(options.path);
+        if (options.output) {
+          writeFileSync(options.output, diagram);
+          console.log(`✅ Diagram saved to: ${options.output}`);
+        } 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 {
+          console.log(`Score: ${score.overall}/100`);
+          for (const [name, value] of Object.entries(score.breakdown)) {
+            console.log(`  ${name}: ${value}/100`);
+          }
+        }
+        break;
+      }
+
+      case 'anti-patterns': {
+        const patterns = await architect.antiPatterns(options.path);
+        if (options.format === 'json') {
+          console.log(JSON.stringify(patterns, null, 2));
+        } else {
+          console.log(`Found ${patterns.length} anti-pattern(s):\n`);
+          for (const p of patterns) {
+            console.log(`  [${p.severity}] ${p.name}: ${p.description}`);
+          }
+        }
+        break;
+      }
+
+      case 'layers': {
+        const layers = await architect.layers(options.path);
+        if (options.format === 'json') {
+          console.log(JSON.stringify(layers, null, 2));
+        } else {
+          for (const l of layers) {
+            console.log(`${l.name}: ${l.files.length} files`);
+          }
+        }
+        break;
+      }
+
+      default:
+        console.error(`❌ Unknown command: ${options.command}`);
+        printUsage();
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error('❌ Error:', error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+main();

package/src/config.ts

@@ -0,0 +1,82 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { ArchitectConfig } from './types.js';
+
+const DEFAULT_CONFIG: ArchitectConfig = {
+  ignore: [
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.git',
+    '.next',
+    'venv',
+    '__pycache__',
+    'target',
+  ],
+  frameworks: {
+    detect: true,
+  },
+  antiPatterns: {
+    godClass: {
+      linesThreshold: 500,
+      methodsThreshold: 10,
+    },
+    shotgunSurgery: {
+      changePropagationThreshold: 5,
+    },
+  },
+  score: {
+    modularity: 0.4,
+    coupling: 0.25,
+    cohesion: 0.2,
+    layering: 0.15,
+  },
+};
+
+export class ConfigLoader {
+  static loadConfig(projectPath: string): ArchitectConfig {
+    const configPath = join(projectPath, '.architect.json');
+
+    try {
+      const content = readFileSync(configPath, 'utf-8');
+      const userConfig = JSON.parse(content) as ArchitectConfig;
+      return this.mergeConfigs(DEFAULT_CONFIG, userConfig);
+    } catch {
+      return DEFAULT_CONFIG;
+    }
+  }
+
+  private static mergeConfigs(
+    defaults: ArchitectConfig,
+    user: ArchitectConfig
+  ): ArchitectConfig {
+    return {
+      ignore: user.ignore ?? defaults.ignore,
+      frameworks: {
+        detect: user.frameworks?.detect ?? defaults.frameworks?.detect,
+      },
+      antiPatterns: {
+        godClass: {
+          linesThreshold:
+            user.antiPatterns?.godClass?.linesThreshold ??
+            defaults.antiPatterns?.godClass?.linesThreshold,
+          methodsThreshold:
+            user.antiPatterns?.godClass?.methodsThreshold ??
+            defaults.antiPatterns?.godClass?.methodsThreshold,
+        },
+        shotgunSurgery: {
+          changePropagationThreshold:
+            user.antiPatterns?.shotgunSurgery?.changePropagationThreshold ??
+            defaults.antiPatterns?.shotgunSurgery?.changePropagationThreshold,
+        },
+      },
+      score: {
+        modularity: user.score?.modularity ?? defaults.score?.modularity,
+        coupling: user.score?.coupling ?? defaults.score?.coupling,
+        cohesion: user.score?.cohesion ?? defaults.score?.cohesion,
+        layering: user.score?.layering ?? defaults.score?.layering,
+      },
+    };
+  }
+}

package/src/diagram.ts

@@ -0,0 +1,144 @@
+import { DependencyEdge, Layer } from './types.js';
+
+export class DiagramGenerator {
+  generateComponentDiagram(
+    edges: DependencyEdge[],
+    layers: Layer[]
+  ): string {
+    const nodes = new Set<string>();
+    edges.forEach((e) => {
+      nodes.add(e.from);
+      nodes.add(e.to);
+    });
+
+    const nodeColors: Record<string, string> = {};
+    for (const layer of layers) {
+      for (const file of layer.files) {
+        const moduleName = file.split('/').pop() || file;
+        const colorMap: Record<string, string> = {
+          API: '#FFB6C1',
+          Service: '#87CEEB',
+          Data: '#90EE90',
+          UI: '#FFD700',
+          Infrastructure: '#D3D3D3',
+        };
+        nodeColors[moduleName] = colorMap[layer.name] || '#FFFFFF';
+      }
+    }
+
+    let mermaid = 'graph TB\n';
+
+    for (const node of Array.from(nodes).slice(0, 20)) {
+      const moduleName = node.split('/').pop() || node;
+      const color = nodeColors[moduleName] || '#FFFFFF';
+      mermaid += `  ${this.sanitizeNodeName(node)}["${moduleName}"]:::${this.getStyleClass(color)}\n`;
+    }
+
+    mermaid += '\n';
+
+    for (const edge of edges.slice(0, 30)) {
+      mermaid += `  ${this.sanitizeNodeName(edge.from)} --> ${this.sanitizeNodeName(edge.to)}\n`;
+    }
+
+    mermaid += '\n';
+    mermaid += '  classDef apiStyle fill:#FFB6C1,stroke:#333,color:#000\n';
+    mermaid += '  classDef serviceStyle fill:#87CEEB,stroke:#333,color:#000\n';
+    mermaid += '  classDef dataStyle fill:#90EE90,stroke:#333,color:#000\n';
+    mermaid += '  classDef uiStyle fill:#FFD700,stroke:#333,color:#000\n';
+    mermaid += '  classDef infraStyle fill:#D3D3D3,stroke:#333,color:#000\n';
+
+    return mermaid;
+  }
+
+  generateLayerDiagram(layers: Layer[]): string {
+    let mermaid = 'graph LR\n';
+
+    const layerOrder = ['UI', 'API', 'Service', 'Data', 'Infrastructure'];
+    const colorMap: Record<string, string> = {
+      UI: 'uiStyle',
+      API: 'apiStyle',
+      Service: 'serviceStyle',
+      Data: 'dataStyle',
+      Infrastructure: 'infraStyle',
+    };
+
+    for (const layerName of layerOrder) {
+      const layer = layers.find((l) => l.name === layerName);
+      if (layer && layer.files.length > 0) {
+        const nodeId = layerName.replace(/\s+/g, '_');
+        const fileCount = layer.files.length;
+        mermaid += `  ${nodeId}["${layerName}<br/>(${fileCount} files)"]:::${colorMap[layerName]}\n`;
+      }
+    }
+
+    for (let i = 0; i < layerOrder.length - 1; i++) {
+      const from = layerOrder[i].replace(/\s+/g, '_');
+      const to = layerOrder[i + 1].replace(/\s+/g, '_');
+      mermaid += `  ${from} --> ${to}\n`;
+    }
+
+    mermaid += '\n';
+    mermaid += '  classDef apiStyle fill:#FFB6C1,stroke:#333,color:#000\n';
+    mermaid += '  classDef serviceStyle fill:#87CEEB,stroke:#333,color:#000\n';
+    mermaid += '  classDef dataStyle fill:#90EE90,stroke:#333,color:#000\n';
+    mermaid += '  classDef uiStyle fill:#FFD700,stroke:#333,color:#000\n';
+    mermaid += '  classDef infraStyle fill:#D3D3D3,stroke:#333,color:#000\n';
+
+    return mermaid;
+  }
+
+  generateDependencyFlowDiagram(edges: DependencyEdge[]): string {
+    const flowMap: Record<string, number> = {};
+
+    for (const edge of edges) {
+      const flowKey = `${edge.from} -> ${edge.to}`;
+      flowMap[flowKey] = (flowMap[flowKey] || 0) + edge.weight;
+    }
+
+    const topFlows = Object.entries(flowMap)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 15);
+
+    let mermaid = 'graph LR\n';
+
+    const nodes = new Set<string>();
+    for (const [flow] of topFlows) {
+      const [from, _, to] = flow.split(' ');
+      nodes.add(from);
+      nodes.add(to);
+    }
+
+    for (const node of nodes) {
+      const moduleName = node.split('/').pop() || node;
+      mermaid += `  ${this.sanitizeNodeName(node)}["${moduleName}"]\n`;
+    }
+
+    mermaid += '\n';
+
+    for (const [flow, weight] of topFlows) {
+      const [from, _, to] = flow.split(' ');
+      const label = weight > 1 ? ` | ${weight}` : '';
+      mermaid += `  ${this.sanitizeNodeName(from)} -->|${label}| ${this.sanitizeNodeName(to)}\n`;
+    }
+
+    return mermaid;
+  }
+
+  private sanitizeNodeName(path: string): string {
+    return path
+      .replace(/[^a-zA-Z0-9]/g, '_')
+      .replace(/_+/g, '_')
+      .toLowerCase();
+  }
+
+  private getStyleClass(color: string): string {
+    const classMap: Record<string, string> = {
+      '#FFB6C1': 'apiStyle',
+      '#87CEEB': 'serviceStyle',
+      '#90EE90': 'dataStyle',
+      '#FFD700': 'uiStyle',
+      '#D3D3D3': 'infraStyle',
+    };
+    return classMap[color] || 'defaultStyle';
+  }
+}