@girardelli/architect-core 8.1.0

package/src/core/ast/tree-sitter-parser.ts

@@ -0,0 +1,158 @@
+import path from 'path';
+import { ASTParser } from './ast-parser.interface.js';
+
+export class TreeSitterParser implements ASTParser {
+  private parsers: Map<string, any> = new Map();
+  private queries: Map<string, any> = new Map();
+  
+  // Store the classes dynamically to avoid static C++ addon evaluation leaks in Jest ESM VMs
+  private ParserClass: any = null;
+  private QueryClass: any = null;
+
+  async initialize(): Promise<void> {
+    try {
+      // Defer loading the native C++ bindings until absolutely needed.
+      // This prevents "Cannot read properties of undefined (reading 'tree')"
+      // when Jest loads the file across multiple test suites concurrently.
+      const treeSitterCore = await import('tree-sitter');
+      this.ParserClass = treeSitterCore.default;
+      this.QueryClass = treeSitterCore.Query;
+
+      // Dynamic ESM imports to handle native bindings gracefully
+      const tsMod = await import('tree-sitter-typescript').catch(() => null);
+      const jsMod = await import('tree-sitter-javascript').catch(() => null);
+      const pyMod = await import('tree-sitter-python').catch(() => null);
+      const goMod = await import('tree-sitter-go').catch(() => null);
+      const javaMod = await import('tree-sitter-java').catch(() => null);
+      const rustMod = await import('tree-sitter-rust').catch(() => null);
+
+      if (tsMod) {
+        // Handle CJS vs ESM interop structures
+        const tsLang = tsMod.default?.typescript || tsMod.typescript || tsMod;
+        const tsxLang = tsMod.default?.tsx || tsMod.tsx;
+        this.initParser('.ts', tsLang);
+        this.initParser('.tsx', tsxLang);
+      }
+
+      if (jsMod) {
+        const jsLang = jsMod.default || jsMod;
+        this.initParser('.js', jsLang);
+        this.initParser('.jsx', jsLang);
+      }
+
+      if (pyMod) {
+        this.initParser('.py', pyMod.default || pyMod);
+      }
+
+      if (goMod) {
+        this.initParser('.go', goMod.default || goMod);
+      }
+
+      if (javaMod) {
+        this.initParser('.java', javaMod.default || javaMod);
+      }
+
+      if (rustMod) {
+        this.initParser('.rs', rustMod.default || rustMod);
+      }
+
+      if (this.parsers.size === 0) {
+        throw new Error('No Tree-Sitter grammars were successfully loaded.');
+      }
+    } catch (err) {
+      throw new Error(`AST Parsers failed to initialize: ${(err as Error).message}`);
+    }
+  }
+
+  private initParser(ext: string, languageOption: any): void {
+    if (!languageOption || !this.ParserClass) return;
+    try {
+      const parser = new this.ParserClass();
+      parser.setLanguage(languageOption);
+      this.parsers.set(ext, parser);
+
+      // Pre-compile queries for performance based on language
+      let queryStr = '';
+      if (ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx') {
+        // Matches "import X from 'path'", "import('path')", "require('path')", "export * from 'path'"
+        queryStr = `
+          (import_statement source: (string) @path)
+          (export_statement source: (string) @path)
+          (call_expression
+            function: [(identifier) (import)] @fn
+            arguments: (arguments (string) @path)
+            (#match? @fn "^(require|import)$")
+          )
+        `;
+      } else if (ext === '.py') {
+        // python imports
+        queryStr = `
+          (import_from_statement module_name: (_) @module)
+          (import_statement name: (_) @module)
+        `;
+      } else if (ext === '.go') {
+        queryStr = `
+          (import_spec path: (interpreted_string_literal) @path)
+        `;
+      } else if (ext === '.java') {
+        queryStr = `
+          (import_declaration (scoped_identifier) @path)
+        `;
+      } else if (ext === '.rs') {
+        queryStr = `
+          (use_declaration argument: (scoped_identifier) @path)
+        `;
+      }
+
+      if (queryStr) {
+        const query = new this.QueryClass(languageOption, queryStr);
+        this.queries.set(ext, query);
+      }
+    } catch (e) {
+      console.error(`[TreeSitter] Query compilation failed for ${ext}:`, e);
+      // Ignore parser failure for a specific extension silently, letting fallback take over
+    }
+  }
+
+  parseImports(content: string, filePath: string): string[] {
+    const ext = path.extname(filePath);
+    const parser = this.parsers.get(ext);
+    const query = this.queries.get(ext);
+
+    if (!parser || !query) {
+      throw new Error(`Tree-Sitter parser not mapped/loaded for extension ${ext}`);
+    }
+
+    const tree = parser.parse(content);
+    const matches = query.matches(tree.rootNode);
+    
+    const imports: string[] = [];
+
+    for (const match of matches) {
+      // Extract the captured module paths/names
+      for (const capture of match.captures) {
+        if (capture.name === 'path' || capture.name === 'module') {
+          // Remove quotes around literal strings (e.g., "'./module'" -> "./module")
+          let value = capture.node.text.replace(/['"]/g, '');
+          
+          if (ext === '.py') {
+            value = value.split(' as ')[0].trim();
+          }
+          
+          imports.push(value);
+        }
+      }
+    }
+
+    // Anti-GC trick for V8 + node-tree-sitter: 
+    // If the 'tree' object is not referenced after 'query.matches()', V8's aggressive GC
+    // might destroy the Tree before 'query.matches' fully executes its C++ bindings,
+    // resulting in "Cannot read properties of undefined (reading 'tree')" inside marshalNode.
+    // Calling tree.delete() explicitly fixes memory leaks AND keeps the reference alive.
+    if (typeof (tree as any).delete === 'function') {
+      (tree as any).delete();
+    }
+
+    return imports;
+  }
+}

package/src/core/config.ts

@@ -0,0 +1,125 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { ArchitectConfig } from './types/core.js';
+
+const DEFAULT_CONFIG: ArchitectConfig = {
+  ignore: [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/coverage/**',
+    '**/.git/**',
+    '**/.next/**',
+    '**/venv/**',
+    '**/__pycache__/**',
+    '**/target/**',
+    '**/out/**',
+    '**/.cache/**',
+  ],
+  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,
+  },
+  monorepo: {
+    enabled: true,
+    treatPackagesAsModules: true,
+  },
+  plugins: [],
+};
+
+/**
+ * Normalize ignore patterns to use proper glob syntax.
+ * Simple names like "node_modules" are expanded to cover nested directories:
+ * "node_modules" → ["node_modules", "node_modules/**", "** /node_modules", "** /node_modules/**"]
+ */
+export function normalizeIgnorePatterns(patterns: string[]): string[] {
+  const normalized = new Set<string>();
+
+  for (const p of patterns) {
+    if (p.includes('*') || p.includes('/')) {
+      // Already a glob pattern — keep as-is
+      normalized.add(p);
+    } else {
+      // Simple directory name — expand to cover all nesting levels
+      normalized.add(p);
+      normalized.add(`${p}/**`);
+      normalized.add(`**/${p}`);
+      normalized.add(`**/${p}/**`);
+    }
+  }
+
+  return [...normalized];
+}
+
+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 {
+    // If user provides ignore patterns, normalize them to proper glob format
+    const userIgnore = user.ignore
+      ? normalizeIgnorePatterns(user.ignore)
+      : defaults.ignore;
+
+    return {
+      ignore: userIgnore,
+      plugins: user.plugins ?? defaults.plugins,
+      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,
+      },
+      monorepo: {
+        enabled: user.monorepo?.enabled ?? defaults.monorepo?.enabled,
+        treatPackagesAsModules:
+          user.monorepo?.treatPackagesAsModules ??
+          defaults.monorepo?.treatPackagesAsModules,
+      },
+    };
+  }
+}

package/src/core/diagram.ts

@@ -0,0 +1,129 @@
+import { DependencyEdge, Layer } from './types/core.js';
+
+const LAYER_THEME: Record<string, { color: string; style: string }> = {
+  API: { color: '#FFB6C1', style: 'apiStyle' },
+  Service: { color: '#87CEEB', style: 'serviceStyle' },
+  Data: { color: '#90EE90', style: 'dataStyle' },
+  UI: { color: '#FFD700', style: 'uiStyle' },
+  Infrastructure: { color: '#D3D3D3', style: 'infraStyle' },
+};
+
+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;
+        nodeColors[moduleName] = LAYER_THEME[layer.name]?.color || '#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`;
+    }
+
+    return this.appendCommonClassDefs(mermaid);
+  }
+
+  generateLayerDiagram(layers: Layer[]): string {
+    let mermaid = 'graph LR\n';
+
+    const layerOrder = ['UI', 'API', 'Service', 'Data', 'Infrastructure'];
+
+    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;
+        const style = LAYER_THEME[layerName]?.style || 'defaultStyle';
+        mermaid += `  ${nodeId}["${layerName}<br/>(${fileCount} files)"]:::${style}\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`;
+    }
+
+    return this.appendCommonClassDefs(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; // specific diagram that doesn't use standard classDefs
+  }
+
+  private sanitizeNodeName(path: string): string {
+    return path
+      .replace(/[^a-zA-Z0-9]/g, '_')
+      .replace(/_+/g, '_')
+      .toLowerCase();
+  }
+
+  private getStyleClass(color: string): string {
+    const match = Object.values(LAYER_THEME).find(t => t.color === color);
+    return match ? match.style : 'defaultStyle';
+  }
+
+  private appendCommonClassDefs(mermaid: string): string {
+    let result = mermaid + '\n';
+    result += '  classDef apiStyle fill:#FFB6C1,stroke:#333,color:#000\n';
+    result += '  classDef serviceStyle fill:#87CEEB,stroke:#333,color:#000\n';
+    result += '  classDef dataStyle fill:#90EE90,stroke:#333,color:#000\n';
+    result += '  classDef uiStyle fill:#FFD700,stroke:#333,color:#000\n';
+    result += '  classDef infraStyle fill:#D3D3D3,stroke:#333,color:#000\n';
+    return result;
+  }
+}

package/src/core/i18n.ts

@@ -0,0 +1,64 @@
+import { en } from './locales/en.js';
+import { ptBR, AppTranslation } from './locales/pt-BR.js';
+
+type Locale = 'en' | 'pt-BR';
+
+class I18nEngine {
+  private currentLocale: Locale = 'en';
+
+  setLocale(locale: Locale) {
+    if (locale === 'en' || locale === 'pt-BR') {
+      this.currentLocale = locale;
+    } else {
+      this.currentLocale = 'en';
+    }
+  }
+
+  getLocale(): Locale {
+    return this.currentLocale;
+  }
+
+  private getDict(): AppTranslation {
+    return this.currentLocale === 'pt-BR' ? ptBR : en;
+  }
+
+  /**
+   * Obtém uma string de tradução navegando pela dot notation da AppTranslation.
+   * Exemplo: t('agents.backend.title', { lang: 'TypeScript' })
+   */
+  t(path: string, params?: Record<string, string | number>): string {
+    const keys = path.split('.');
+    let current: any = this.getDict();
+
+    for (const key of keys) {
+      if (current[key] === undefined) {
+        // Fallback to EN if missing in current dict
+        let fallback: any = en;
+        for (const fKey of keys) {
+          if (fallback[fKey] === undefined) return `[Missing translation: ${path}]`;
+          fallback = fallback[fKey];
+        }
+        current = fallback;
+        break;
+      }
+      current = current[key];
+    }
+
+    if (typeof current !== 'string') {
+      return `[Invalid translation path: ${path}]`;
+    }
+
+    let text = current as string;
+    
+    // Replace params: {fw} -> value
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        text = text.replace(new RegExp(`{${key}}`, 'g'), String(value));
+      }
+    }
+
+    return text;
+  }
+}
+
+export const i18n = new I18nEngine();