@girardelli/architect 4.0.0 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girardelli/architect",
-  "version": "4.0.0",
+  "version": "6.0.0",
   "type": "module",
   "description": "AI-powered architecture analysis with temporal intelligence — git history, velocity vectors, pre-anti-pattern detection, and architecture weather forecast",
   "author": {
@@ -22,13 +22,13 @@
     }
   },
   "bin": {
-    "architect": "./dist/cli.js"
+    "architect": "./dist/adapters/cli.js"
   },
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist",
     "dev": "tsc --watch",
-    "analyze": "node dist/cli.js analyze",
+    "analyze": "node dist/adapters/cli.js analyze",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch",
     "lint": "eslint src --ext .ts",

package/scripts/decompose-detectors.ts

@@ -0,0 +1,183 @@
+import { FrameworkInfo, BaseDetector, FRAMEWORK_MAP, AnalysisReport, FrameworkInfo, DetectedToolchain, FrameworkInfo, DetectedToolchain, PythonDetector, NodeDetector, JavaDetector, PhpDetector, GoDetector, RubyDetector, DartDetector, RustDetector, ToolchainDetector, StructureDetector } from './decompose-detectors_deps.js';
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const SRC = 'src/agent-generator/framework-detector.ts';
+const DEST_DIR = 'src/agent-generator/detectors';
+
+if (!existsSync(DEST_DIR)) mkdirSync(DEST_DIR, { recursive: true });
+
+// Read original
+const content = readFileSync(SRC, 'utf8');
+
+// 1. EXTRACT FRAMEWORK_MAP into framework-registry.ts
+const mapMatch = content.match(/(private static readonly FRAMEWORK_MAP[\s\S]*?);/);
+let mapCode = mapMatch ? mapMatch[1].replace('private static readonly', 'export const') + ';' : '';
+
+writeFileSync(join(DEST_DIR, 'framework-registry.ts'), `\n\n${mapCode}\n`);
+
+// 2. Base Detector Strategy
+const baseStrategy = `import { FrameworkInfo } from '../types.js';
+import { readFileSync } from 'fs';
+
+export interface FrameworkDetectorStrategy {
+  detect(projectPath: string, out: FrameworkInfo[]): void;
+}
+
+export abstract class BaseDetector implements FrameworkDetectorStrategy {
+  abstract detect(projectPath: string, out: FrameworkInfo[]): void;
+
+  protected safeReadFile(path: string): string {
+    try {
+      return readFileSync(path, 'utf-8');
+    } catch {
+      return '';
+    }
+  }
+}
+`;
+writeFileSync(join(DEST_DIR, 'base-detector.ts'), baseStrategy);
+
+// 3. Extract languages
+const methods = [
+  { file: 'python-detector.ts', class: 'PythonDetector', method: 'detectFromPython', helpers: ['parsePythonRequirements', 'parsePyprojectToml'] },
+  { file: 'node-detector.ts', class: 'NodeDetector', method: 'detectFromNodejs', helpers: [] },
+  { file: 'java-detector.ts', class: 'JavaDetector', method: 'detectFromJava', helpers: [] },
+  { file: 'php-detector.ts', class: 'PhpDetector', method: 'detectFromPhp', helpers: [] },
+  { file: 'go-detector.ts', class: 'GoDetector', method: 'detectFromGo', helpers: [] },
+  { file: 'ruby-detector.ts', class: 'RubyDetector', method: 'detectFromRuby', helpers: [] },
+  { file: 'dart-detector.ts', class: 'DartDetector', method: 'detectFromDart', helpers: [] },
+  { file: 'rust-detector.ts', class: 'RustDetector', method: 'detectFromRust', helpers: [] }
+];
+
+methods.forEach(def => {
+  let clsBody = '';
+  
+  // Extract main method
+  const methodRegex = new RegExp(`(private ${def.method}\\([\\s\\S]*?\\n  })\\n\\n`, 'g');
+  const mainMatch = content.match(methodRegex);
+  if (mainMatch) clsBody += mainMatch[0].replace('private ', 'public ') + '\n';
+  else {
+    const singleMatch = content.match(new RegExp(`(private ${def.method}[\\s\\S]*?)(?:\\n  private |\\n\\n  /|\\n})`));
+    if (singleMatch) clsBody += singleMatch[1].replace('private ', 'public ') + '\n';
+  }
+
+  // Extract helpers
+  def.helpers.forEach(h => {
+    const r = new RegExp(`private ${h}\\([\\s\\S]*?\\n(?:  })\\n`);
+    const m = content.match(r);
+    if (m) clsBody += m[0];
+  });
+
+  // Inject FRAMEWORK_MAP usage
+  clsBody = clsBody.replace(/FrameworkDetector\.FRAMEWORK_MAP/g, 'FRAMEWORK_MAP');
+
+  const fileContent = `import { join } from 'path';
+import { existsSync } from 'fs';
+import { FrameworkInfo } from '../types.js';
+
+
+
+export class ${def.class} extends BaseDetector {
+${clsBody.trim()}
+}
+`;
+  writeFileSync(join(DEST_DIR, def.file), fileContent);
+});
+
+// 4. Extract Toolchain
+const toolchainMatch = content.match(/(private detectToolchain[\s\S]+?)\n\n  \/\//);
+let toolchainCode = toolchainMatch ? toolchainMatch[1].replace('private detectToolchain', 'public detectToolchain') : '';
+
+const structMatch = content.match(/(private detectProjectStructure[\s\S]+?})\n\n/);
+let structCode = structMatch ? structMatch[1].replace('private detectProjectStructure', 'public detectProjectStructure') : '';
+
+writeFileSync(join(DEST_DIR, 'toolchain-detector.ts'), `import { existsSync } from 'fs';
+import { join } from 'path';
+
+
+
+export class ToolchainDetector {
+${toolchainCode}
+}
+`);
+
+writeFileSync(join(DEST_DIR, 'structure-detector.ts'), `import { AnalysisReport } from '../../types.js';
+
+export class StructureDetector {
+${structCode}
+}
+`);
+
+// 5. Build Facade Index
+const facade = `import { AnalysisReport } from '../../types.js';
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * FrameworkDetector — Detects actual frameworks and toolchain from dependency files.
+ * Re-architected as a Strategy/Registry Facade.
+ */
+export class FrameworkDetector {
+  private detectors = [
+    new PythonDetector(),
+    new NodeDetector(),
+    new JavaDetector(),
+    new PhpDetector(),
+    new GoDetector(),
+    new RubyDetector(),
+    new DartDetector(),
+    new RustDetector()
+  ];
+  private toolchainDetector = new ToolchainDetector();
+  private structureDetector = new StructureDetector();
+
+  detect(projectPath: string, report: AnalysisReport): {
+    frameworks: FrameworkInfo[];
+    primaryFramework: FrameworkInfo | null;
+    toolchain: DetectedToolchain;
+    projectStructure: 'clean-architecture' | 'mvc' | 'modular' | 'flat' | 'monorepo' | 'unknown';
+  } {
+    const frameworks: FrameworkInfo[] = [];
+
+    // Run all detectors
+    for (const detector of this.detectors) {
+      detector.detect(projectPath, frameworks);
+    }
+
+    // Deduplicate by name
+    const seen = new Set<string>();
+    const unique = frameworks.filter(f => {
+      if (seen.has(f.name)) return false;
+      seen.add(f.name);
+      return true;
+    });
+
+    // Sort: web frameworks first, then by confidence
+    unique.sort((a, b) => {
+      if (a.category === 'web' && b.category !== 'web') return -1;
+      if (a.category !== 'web' && b.category === 'web') return 1;
+      return b.confidence - a.confidence;
+    });
+
+    const primaryFramework = unique.find(f => f.category === 'web') || null;
+    const toolchain = this.toolchainDetector.detectToolchain(projectPath, report, primaryFramework, unique);
+    const projectStructure = this.structureDetector.detectProjectStructure(report);
+
+    return { frameworks: unique, primaryFramework, toolchain, projectStructure };
+  }
+}
+`;
+
+writeFileSync('src/agent-generator/framework-detector.ts', facade);
+console.log('Done mapping components!');

package/scripts/decompose-detectors_deps.ts

@@ -0,0 +1,16 @@
+export { FrameworkInfo } from '../types.js';
+export { BaseDetector } from './base-detector.js';
+export { FRAMEWORK_MAP } from './framework-registry.js';
+export { AnalysisReport } from '../../types.js';
+export { FrameworkInfo, DetectedToolchain } from '../types.js';
+export { FrameworkInfo, DetectedToolchain } from './types.js';
+export { PythonDetector } from './detectors/python-detector.js';
+export { NodeDetector } from './detectors/node-detector.js';
+export { JavaDetector } from './detectors/java-detector.js';
+export { PhpDetector } from './detectors/php-detector.js';
+export { GoDetector } from './detectors/go-detector.js';
+export { RubyDetector } from './detectors/ruby-detector.js';
+export { DartDetector } from './detectors/dart-detector.js';
+export { RustDetector } from './detectors/rust-detector.js';
+export { ToolchainDetector } from './detectors/toolchain-detector.js';
+export { StructureDetector } from './detectors/structure-detector.js';

package/scripts/decompose-enrichers.ts

@@ -0,0 +1,191 @@
+import { AnalysisReport, ModuleDetail, DetectedEndpoint, EnrichedTemplateContext, DescriptionGenerator, AnalysisHelpers, StackInfo, EnrichedTemplateContext, AgentGeneratorConfig, DEFAULT_AGENT_CONFIG, DomainInferrer, FrameworkDetector, ModuleExtractor, EndpointExtractor, AnalysisHelpers } from './decompose-enrichers_deps.js';
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const SRC = 'src/agent-generator/context-enricher.ts';
+const DEST_DIR = 'src/agent-generator/enrichers';
+
+if (!existsSync(DEST_DIR)) mkdirSync(DEST_DIR, { recursive: true });
+
+const content = readFileSync(SRC, 'utf8');
+
+// 1. DTO and TYPES
+const baseImports = `import { existsSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+
+\n\n`;
+
+// Extract Classifiers
+// Layer Classifier (isTest, isEntity, isController, isGenericDir, inferFileLayer, etc)
+
+let layerClassifier = baseImports + `export class LayerClassifier {
+`;
+const layerMethods = [
+  'isTestFile', 'isEntityFile', 'isControllerOrRouteFile', 
+  'isServiceFile', 'isGenericDir', 'inferFileLayer', 'extractEntityName',
+  'fileReferencesAuth', 'fileReferencesValidation'
+];
+
+layerMethods.forEach(m => {
+  const r = new RegExp(`private ${m}\\([\\w\\W]*?\\n(?:  }\\n(?:\\n|  //))`);
+  const match = content.match(r);
+  if (match) {
+    layerClassifier += match[0].replace('private ', 'public ') + '\n';
+  }
+});
+layerClassifier += `}\n`;
+writeFileSync(join(DEST_DIR, 'layer-classifier.ts'), layerClassifier);
+
+// Description Generator 
+let descGenerator = baseImports + `export class DescriptionGenerator {
+`;
+const descMatch = content.match(/(private generateSmartDescription[\w\W]*?\n  }\n)/);
+if (descMatch) {
+  descGenerator += descMatch[1].replace('private ', 'public ') + '\n';
+}
+descGenerator += `}\n`;
+writeFileSync(join(DEST_DIR, 'description-generator.ts'), descGenerator);
+
+// Analysis Helpers (findUntestedModules, countFileLines, classifyProjectDepth, findCriticalPaths)
+let analysisHelpers = baseImports + `export class AnalysisHelpers {
+`;
+['findUntestedModules', 'findCriticalPaths', 'classifyProjectDepth', 'countFileLines'].forEach(m => {
+  const r = new RegExp(`private ${m}\\([\\w\\W]*?\\n(?:  }\\n(?:\\n|  //))`);
+  const match = content.match(r);
+  if (match) {
+    analysisHelpers += match[0].replace('private ', 'public ') + '\n';
+  }
+});
+analysisHelpers += `}\n`;
+writeFileSync(join(DEST_DIR, 'analysis-helpers.ts'), analysisHelpers);
+
+// Module Extractor
+let modExtractor = baseImports + `import { LayerClassifier } from './layer-classifier.js';
+
+
+
+export class ModuleExtractor {
+  private layerClassifier = new LayerClassifier();
+  private descriptionGenerator = new DescriptionGenerator();
+  private analysisHelpers = new AnalysisHelpers();
+
+`;
+['extractModules', 'inferModuleName', 'inferModulePath'].forEach(m => {
+  const r = new RegExp(`private ${m}\\([\\w\\W]*?\\n(?:  }\\n(?:\\n|  //))`);
+  const match = content.match(r);
+  if (match) {
+    let methodBody = match[0].replace('private ', 'public ');
+    
+    // Rewrite "this." references 
+    methodBody = methodBody.replace(/this\.inferModuleName/g, 'this.inferModuleName');
+    methodBody = methodBody.replace(/this\.inferModulePath/g, 'this.inferModulePath');
+    methodBody = methodBody.replace(/this\.countFileLines/g, 'this.analysisHelpers.countFileLines');
+    methodBody = methodBody.replace(/this\.inferFileLayer/g, 'this.layerClassifier.inferFileLayer');
+    methodBody = methodBody.replace(/this\.isTestFile/g, 'this.layerClassifier.isTestFile');
+    methodBody = methodBody.replace(/this\.isEntityFile/g, 'this.layerClassifier.isEntityFile');
+    methodBody = methodBody.replace(/this\.isControllerOrRouteFile/g, 'this.layerClassifier.isControllerOrRouteFile');
+    methodBody = methodBody.replace(/this\.isServiceFile/g, 'this.layerClassifier.isServiceFile');
+    methodBody = methodBody.replace(/this\.extractEntityName/g, 'this.layerClassifier.extractEntityName');
+    methodBody = methodBody.replace(/this\.generateSmartDescription/g, 'this.descriptionGenerator.generateSmartDescription');
+    methodBody = methodBody.replace(/this\.isGenericDir/g, 'this.layerClassifier.isGenericDir');
+
+    modExtractor += methodBody + '\n';
+  }
+});
+modExtractor += `}\n`;
+writeFileSync(join(DEST_DIR, 'module-extractor.ts'), modExtractor);
+
+// Endpoint Extractor
+let endExtractor = baseImports + `import { LayerClassifier } from './layer-classifier.js';
+
+export class EndpointExtractor {
+  private layerClassifier = new LayerClassifier();
+
+`;
+['extractEndpoints', 'extractResourceFromFile'].forEach(m => {
+  const r = new RegExp(`private ${m}\\([\\w\\W]*?\\n(?:  }\\n(?:\\n|  //))`);
+  const match = content.match(r);
+  if (match) {
+    let methodBody = match[0].replace('private ', 'public ');
+    
+    // Rewrite "this." references 
+    methodBody = methodBody.replace(/this\.isControllerOrRouteFile/g, 'this.layerClassifier.isControllerOrRouteFile');
+    methodBody = methodBody.replace(/this\.fileReferencesAuth/g, 'this.layerClassifier.fileReferencesAuth');
+    methodBody = methodBody.replace(/this\.fileReferencesValidation/g, 'this.layerClassifier.fileReferencesValidation');
+    methodBody = methodBody.replace(/this\.extractResourceFromFile/g, 'this.extractResourceFromFile');
+
+    endExtractor += methodBody + '\n';
+  }
+});
+endExtractor += `}\n`;
+writeFileSync(join(DEST_DIR, 'endpoint-extractor.ts'), endExtractor);
+
+// Finally, rebuild context-enricher.ts Facade
+const facade = `import { AnalysisReport, RefactoringPlan } from '../types.js';
+
+
+
+
+// Engines
+
+
+
+
+/**
+ * ContextEnricher — Builds an EnrichedTemplateContext from AnalysisReport.
+ * Refactored via Strategy/Facade into separate Extractor engines.
+ */
+export class ContextEnricher {
+  private domainInferrer = new DomainInferrer();
+  private frameworkDetector = new FrameworkDetector();
+  
+  private moduleExtractor = new ModuleExtractor();
+  private endpointExtractor = new EndpointExtractor();
+  private analysisHelpers = new AnalysisHelpers();
+
+  enrich(
+    report: AnalysisReport,
+    plan: RefactoringPlan,
+    stack: StackInfo,
+    projectPath: string,
+    config: AgentGeneratorConfig = DEFAULT_AGENT_CONFIG,
+  ): EnrichedTemplateContext {
+    const modules = this.moduleExtractor.extractModules(report, projectPath);
+    const endpoints = this.endpointExtractor.extractEndpoints(report, modules);
+    const untestedModules = this.analysisHelpers.findUntestedModules(modules);
+    const criticalPaths = this.analysisHelpers.findCriticalPaths(report);
+    const projectDepth = this.analysisHelpers.classifyProjectDepth(report);
+    const domain = this.domainInferrer.infer(report, projectPath);
+
+    const fwResult = this.frameworkDetector.detect(projectPath, report);
+
+    const webFrameworks = (report.projectInfo?.frameworks || [])
+      .filter(f => !['Jest', 'Vitest', 'Mocha', 'ESLint', 'Prettier', 'Biome',
+        'pytest', 'Ruff', 'mypy', 'Black', 'Flake8', 'RSpec',
+        '@jest/globals', '@types/jest', 'ts-jest'].includes(f));
+    const stackLabel = [...new Set([...stack.languages, ...webFrameworks])].join(' + ');
+
+    return {
+      report,
+      plan,
+      stack,
+      projectName: report.projectInfo.name || 'Project',
+      stackLabel,
+      config,
+      domain,
+      modules,
+      endpoints,
+      untestedModules,
+      criticalPaths,
+      projectDepth,
+      detectedFrameworks: fwResult.frameworks,
+      primaryFramework: fwResult.primaryFramework,
+      toolchain: fwResult.toolchain,
+      projectStructure: fwResult.projectStructure,
+    };
+  }
+}
+`;
+writeFileSync(SRC, facade);
+console.log('Enrichers created and context-enricher Facade compiled!');

package/scripts/decompose-enrichers_deps.ts

@@ -0,0 +1,10 @@
+export { AnalysisReport } from '../../types.js';
+export { ModuleDetail, DetectedEndpoint, EnrichedTemplateContext } from '../types.js';
+export { DescriptionGenerator } from './description-generator.js';
+export { AnalysisHelpers } from './analysis-helpers.js';
+export { StackInfo, EnrichedTemplateContext, AgentGeneratorConfig, DEFAULT_AGENT_CONFIG } from './types.js';
+export { DomainInferrer } from './domain-inferrer.js';
+export { FrameworkDetector } from './framework-detector.js';
+export { ModuleExtractor } from './enrichers/module-extractor.js';
+export { EndpointExtractor } from './enrichers/endpoint-extractor.js';
+export { AnalysisHelpers } from './enrichers/analysis-helpers.js';

package/scripts/decompose-helpers.ts

@@ -0,0 +1,92 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const SRC = 'src/agent-generator/templates/template-helpers.ts';
+const DEST_DIR = 'src/agent-generator/templates/helpers';
+
+if (!existsSync(DEST_DIR)) mkdirSync(DEST_DIR, { recursive: true });
+
+const content = readFileSync(SRC, 'utf8');
+
+const baseImports = `import { TemplateContext, EnrichedTemplateContext, FrameworkInfo } from '../../types.js';\n\n`;
+
+// 1. Base Helpers
+let baseHelpers = baseImports + `export function getEnriched(ctx: TemplateContext): Partial<EnrichedTemplateContext> {
+  if ('domain' in ctx) return ctx as EnrichedTemplateContext;
+  return {};
+}
+
+export function isEnriched(ctx: TemplateContext): ctx is EnrichedTemplateContext {
+  return 'domain' in ctx;
+}
+`;
+['depthScale', 'depthAtLeast'].forEach(m => {
+  const r = new RegExp(`(export function ${m}[\\w\\W]*?\\n}\\n)`);
+  const match = content.match(r);
+  if (match) baseHelpers += '\n' + match[1];
+});
+// Need to replace getEnriched inside baseHelpers if it lacked an import
+writeFileSync(join(DEST_DIR, 'base-helpers.ts'), baseHelpers);
+
+// 2. Cross Ref Helpers
+let crossRef = `import { TemplateContext } from '../../types.js';\n\n`;
+['crossRef'].forEach(m => {
+  const r = new RegExp(`(export function ${m}[\\w\\W]*?\\n}\\n)`);
+  const match = content.match(r);
+  if (match) crossRef += match[1] + '\n';
+});
+writeFileSync(join(DEST_DIR, 'cross-ref-helpers.ts'), crossRef);
+
+// 3. Summary Helpers
+let summaryHelpers = baseImports + `import { getEnriched, depthScale } from './base-helpers.js';\n\n`;
+['domainBadge', 'complianceBadges', 'depthIndicator', 'modulesSummaryTable', 'integrationsSummary'].forEach(m => {
+  const r = new RegExp(`(export function ${m}[\\w\\W]*?\\n}\\n)`);
+  const match = content.match(r);
+  if (match) summaryHelpers += match[1] + '\n';
+});
+writeFileSync(join(DEST_DIR, 'summary-helpers.ts'), summaryHelpers);
+
+// 4. Stack Helpers
+let stackHelpers = baseImports + `import { getEnriched } from './base-helpers.js';\n\n`;
+['frameworkBadge', 'projectStructureBadge', 'toolchainCommands'].forEach(m => {
+  const r = new RegExp(`(export function ${m}[\\w\\W]*?\\n}\\n)`);
+  const match = content.match(r);
+  if (match) stackHelpers += match[1] + '\n';
+});
+writeFileSync(join(DEST_DIR, 'stack-helpers.ts'), stackHelpers);
+
+// 5. Structure Helpers
+let structureHelpers = baseImports + `import { getEnriched } from './base-helpers.js';\n\n`;
+['frameworkModuleStructure'].forEach(m => {
+  const r = new RegExp(`(export function ${m}[\\w\\W]*?\\n}\\n)`);
+  const match = content.match(r);
+  if (match) structureHelpers += match[1] + '\n';
+});
+writeFileSync(join(DEST_DIR, 'structure-helpers.ts'), structureHelpers);
+
+// 6. Security Helpers
+let securityHelpers = baseImports + `import { getEnriched } from './base-helpers.js';\n\n`;
+['frameworkSecurityChecklist'].forEach(m => {
+  const r = new RegExp(`(export function ${m}[\\w\\W]*?\\n}\\n)`);
+  const match = content.match(r);
+  if (match) securityHelpers += match[1] + '\n';
+});
+writeFileSync(join(DEST_DIR, 'security-helpers.ts'), securityHelpers);
+
+// 7. Rebuild Facade template-helpers.ts
+const facade = `/**
+ * Template Helpers v3.2 — Facade para todos os utilitários agnósticos e estruturais.
+ *
+ * Refatorado na Fase 2.3.4: Erradicação final da God Class (777 → 20 linhas).
+ */
+
+export * from './helpers/base-helpers.js';
+export * from './helpers/cross-ref-helpers.js';
+export * from './helpers/summary-helpers.js';
+export * from './helpers/stack-helpers.js';
+export * from './helpers/structure-helpers.js';
+export * from './helpers/security-helpers.js';
+`;
+writeFileSync(SRC, facade);
+
+console.log('FINAL God Class template-helpers.ts has been shattered into shards!');

package/scripts/decompose-summarizer.ts

@@ -0,0 +1,127 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const SRC = 'src/project-summarizer.ts';
+const DEST_DIR = 'src/summarizer';
+
+if (!existsSync(DEST_DIR)) mkdirSync(DEST_DIR, { recursive: true });
+
+const content = readFileSync(SRC, 'utf8');
+
+const baseImports = `import { existsSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+import { AnalysisReport, ProjectSummary, FileNode, WorkspaceInfo } from '../types.js';\n\n`;
+
+// 1. PackageReader
+let packageReader = baseImports + `export class PackageReader {
+`;
+const mPackage = content.match(/(private readPackageJson[\w\W]*?\n  }\n)/);
+if(mPackage) packageReader += mPackage[1].replace('private ', 'public ') + '\n';
+packageReader += `}\n`;
+writeFileSync(join(DEST_DIR, 'package-reader.ts'), packageReader);
+
+// 2. ReadmeReader
+let readmeReader = baseImports + `export class ReadmeReader {
+`;
+const mReadme = content.match(/(private readReadme[\w\W]*?\n  }\n)/);
+if(mReadme) readmeReader += mReadme[1].replace('private ', 'public ') + '\n';
+readmeReader += `}\n`;
+writeFileSync(join(DEST_DIR, 'readme-reader.ts'), readmeReader);
+
+// 3. KeywordExtractor
+let keywordExt = baseImports + `export class KeywordExtractor {
+  public static readonly KEYWORD_BLACKLIST = new Set([
+    'node_modules', 'dist', 'build', '.git', '.next', 'coverage',
+    '__tests__', '__mocks__', 'src', 'lib', 'index', 'main',
+    'out', 'tmp', '.cache', 'vendor', '.vscode', '.idea',
+  ]);
+
+`;
+const mKey = content.match(/(private extractKeywords[\w\W]*?\n  }\n)/);
+if(mKey) {
+  let body = mKey[1].replace('private ', 'public ');
+  body = body.replace(/ProjectSummarizer\.KEYWORD_BLACKLIST/g, 'KeywordExtractor.KEYWORD_BLACKLIST');
+  keywordExt += body + '\n';
+}
+keywordExt += `}\n`;
+writeFileSync(join(DEST_DIR, 'keyword-extractor.ts'), keywordExt);
+
+// 4. PurposeInferrer (buildTechStack, buildDescription, inferPurpose)
+let purposeInf = baseImports + `export class PurposeInferrer {
+`;
+['buildTechStack', 'buildDescription', 'inferPurpose', 'findEntryPoints'].forEach(m => {
+  const r = new RegExp(`(private ${m}\\([\\w\\W]*?\\n  }\\n)`);
+  const match = content.match(r);
+  if (match) purposeInf += match[1].replace('private ', 'public ') + '\n';
+});
+purposeInf += `}\n`;
+writeFileSync(join(DEST_DIR, 'purpose-inferrer.ts'), purposeInf);
+
+// 5. ModuleInferrer
+let modInf = `import { existsSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+import { AnalysisReport, ProjectSummary, WorkspaceInfo } from '../types.js';
+
+export class ModuleInferrer {
+`;
+['inferModules', 'inferModulesFromWorkspaces', 'getWorkspaceDescription', 'countFilesInDir', 'inferModulesFromStructure', 'describeModule'].forEach(m => {
+  const r = new RegExp(`(private ${m}\\([\\w\\W]*?\\n  }\\n)`);
+  const match = content.match(r);
+  if (match) {
+    let mb = match[1].replace('private ', 'public ');
+    mb = mb.replace(/this\.inferModulesFromWorkspaces/g, 'this.inferModulesFromWorkspaces');
+    mb = mb.replace(/this\.inferModulesFromStructure/g, 'this.inferModulesFromStructure');
+    mb = mb.replace(/this\.getWorkspaceDescription/g, 'this.getWorkspaceDescription');
+    mb = mb.replace(/this\.countFilesInDir/g, 'this.countFilesInDir');
+    mb = mb.replace(/this\.describeModule/g, 'this.describeModule');
+    modInf += mb + '\n';
+  }
+});
+modInf += `}\n`;
+writeFileSync(join(DEST_DIR, 'module-inferrer.ts'), modInf);
+
+// 6. ProjectSummarizer Facade
+const facade = `import { AnalysisReport, ProjectSummary } from './types.js';
+
+import { PackageReader } from './summarizer/package-reader.js';
+import { ReadmeReader } from './summarizer/readme-reader.js';
+import { KeywordExtractor } from './summarizer/keyword-extractor.js';
+import { PurposeInferrer } from './summarizer/purpose-inferrer.js';
+import { ModuleInferrer } from './summarizer/module-inferrer.js';
+
+/**
+ * ProjectSummarizer — infers what a project does from its metadata,
+ * structure, README, package.json, and file naming conventions.
+ *
+ * Refactored via Facade pattern in v5.0.0
+ */
+export class ProjectSummarizer {
+  private packageReader = new PackageReader();
+  private readmeReader = new ReadmeReader();
+  private keywordExtractor = new KeywordExtractor();
+  private purposeInferrer = new PurposeInferrer();
+  private moduleInferrer = new ModuleInferrer();
+
+  summarize(projectPath: string, report: AnalysisReport): ProjectSummary {
+    const packageInfo = this.packageReader.readPackageJson(projectPath);
+    const readmeContent = this.readmeReader.readReadme(projectPath);
+    const modules = this.moduleInferrer.inferModules(report, projectPath);
+    const entryPoints = this.purposeInferrer.findEntryPoints(report, projectPath);
+    const keywords = this.keywordExtractor.extractKeywords(packageInfo, readmeContent, modules, report);
+    const techStack = this.purposeInferrer.buildTechStack(report, packageInfo);
+    const description = this.purposeInferrer.buildDescription(packageInfo, readmeContent, report);
+    const purpose = this.purposeInferrer.inferPurpose(keywords, modules, report);
+
+    return {
+      description,
+      purpose,
+      modules,
+      techStack,
+      entryPoints,
+      keywords,
+    };
+  }
+}
+`;
+writeFileSync(SRC, facade);
+console.log('ProjectSummarizer decomposed and facade generated flawlessly!');

package/setup-refactor.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+echo "=== Iniciando Setup de Refatoração (Fase 2.1) ==="
+
+echo "1. Criando Issue no GitHub..."
+gh issue create \
+  --title "Refatoração (Fase 2.1): Quebrar html-reporter.ts (God File)" \
+  --body "O arquivo src/html-reporter.ts cresceu para ~1800 linhas. Objetivo: Separar CSS, scripts client-side e separar o HTML em sub-seções isoladas (header, score, antipatterns, etc). Requisito: Saída de HTML deve manter 100% de paridade com a versão original." \
+  --label "refactor"
+
+echo "2. Criando Branch..."
+git checkout main
+git pull origin main
+git checkout -b feature/refactor-html-reporter
+
+echo "3. Gerando Snapshot de Referência (Anti-Quebra)..."
+npm run build
+npx architect analyze . > /dev/null
+cp architect-report.html referencia-v5-original.html
+
+echo "=== Setup Concluído! ==="
+echo "O arquivo referencia-v5-original.html foi criado para checagem byte a byte."