@girardelli/architect 6.0.0 → 8.1.0

package/src/infrastructure/scanner.ts

@@ -1,347 +0,0 @@
-import { globSync } from 'glob';
-import { readFileSync, lstatSync, existsSync } from 'fs';
-import { join, relative, extname, resolve } from 'path';
-import { FileNode, ProjectInfo, WorkspaceInfo } from '../core/types/infrastructure.js';
-import { ArchitectConfig } from '../core/types/core.js';
-import { logger } from './logger.js';
-
-export class ProjectScanner {
-  private projectPath: string;
-  private config: ArchitectConfig;
-  private frameworks: Set<string> = new Set();
-
-  constructor(projectPath: string, config: ArchitectConfig) {
-    this.projectPath = projectPath;
-    this.config = config;
-  }
-
-  scan(): ProjectInfo {
-    const files = this.scanDirectory();
-    const fileTree = this.buildFileTree(files);
-
-    // Detect workspaces from root package.json
-    const workspaces = this.detectWorkspaces();
-
-    // Detect frameworks ONLY from root + workspace package.json files (never from node_modules)
-    const workspacePkgJsonPaths = [
-      join(this.projectPath, 'package.json'),
-      ...workspaces.map(ws => join(ws.path, 'package.json')),
-    ].filter(p => existsSync(p));
-
-    const frameworks = this.detectFrameworks(workspacePkgJsonPaths);
-    const languages = this.detectLanguages(files);
-    const totalLines = this.countTotalLines(files);
-    const projectName = this.resolveProjectName(workspacePkgJsonPaths);
-
-    return {
-      path: this.projectPath,
-      name: projectName,
-      frameworks: Array.from(frameworks),
-      totalFiles: files.length,
-      totalLines,
-      primaryLanguages: languages,
-      fileTree,
-      workspaces: workspaces.length > 0 ? workspaces : undefined,
-    };
-  }
-
-  /**
-   * Detect npm/yarn/pnpm workspaces from root package.json.
-   * Reads the "workspaces" field and resolves each workspace to its package.json.
-   */
-  private detectWorkspaces(): WorkspaceInfo[] {
-    const rootPkgPath = join(this.projectPath, 'package.json');
-    if (!existsSync(rootPkgPath)) return [];
-
-    try {
-      const rootPkg = JSON.parse(readFileSync(rootPkgPath, 'utf-8'));
-      let workspaceGlobs: string[] = [];
-
-      if (Array.isArray(rootPkg.workspaces)) {
-        workspaceGlobs = rootPkg.workspaces;
-      } else if (rootPkg.workspaces?.packages && Array.isArray(rootPkg.workspaces.packages)) {
-        workspaceGlobs = rootPkg.workspaces.packages;
-      }
-
-      if (workspaceGlobs.length === 0) return [];
-
-      const workspaces: WorkspaceInfo[] = [];
-
-      for (const pattern of workspaceGlobs) {
-        // Resolve glob patterns like "packages/*"
-        const dirs = globSync(pattern, {
-          cwd: this.projectPath,
-          absolute: true,
-        });
-
-        for (const dir of dirs) {
-          const pkgPath = join(dir, 'package.json');
-          if (!existsSync(pkgPath)) continue;
-
-          try {
-            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-            workspaces.push({
-              name: pkg.name || relative(this.projectPath, dir),
-              path: dir,
-              relativePath: relative(this.projectPath, dir),
-              description: pkg.description || '',
-              version: pkg.version || '0.0.0',
-              dependencies: pkg.dependencies || {},
-              devDependencies: pkg.devDependencies || {},
-              bin: pkg.bin || undefined,
-              main: pkg.main || undefined,
-            });
-          } catch (error) {
-            logger.debug('Skipping unparseable package.json in workspace', { pkgPath, error });
-          }
-        }
-      }
-
-      return workspaces;
-    } catch (error) {
-      logger.debug('Failed to parse root package.json for workspaces', { error });
-      return [];
-    }
-  }
-
-  /**
-   * Resolve project name from nearest package.json or directory name
-   */
-  private resolveProjectName(packageJsonPaths: string[]): string {
-    for (const pkgPath of packageJsonPaths) {
-      try {
-        const content = readFileSync(pkgPath, 'utf-8');
-        const parsed = JSON.parse(content);
-        if (parsed.name) {
-          return parsed.name;
-        }
-      } catch (error) {
-        logger.debug('Skipping unparseable package.json while resolving project name', { pkgPath, error });
-      }
-    }
-    return this.projectPath.split('/').pop() || 'project';
-  }
-
-  private scanDirectory(): string[] {
-    const ignorePatterns = this.config.ignore || [];
-
-    const files = globSync('**/*', {
-      cwd: this.projectPath,
-      ignore: ignorePatterns,
-      absolute: true,
-      nodir: true,
-    });
-
-    return files.filter(
-      (f) =>
-        !lstatSync(f).isDirectory() && this.isSourceFile(f)
-    );
-  }
-
-  private isSourceFile(filePath: string): boolean {
-    const ext = extname(filePath).toLowerCase();
-    const sourceExtensions = [
-      '.js',
-      '.ts',
-      '.tsx',
-      '.jsx',
-      '.py',
-      '.java',
-      '.go',
-      '.rb',
-      '.php',
-      '.cs',
-      '.cpp',
-      '.c',
-      '.h',
-      '.rs',
-      '.kt',
-      '.scala',
-      '.groovy',
-      '.sql',
-      '.graphql',
-      '.json',
-      '.yaml',
-      '.yml',
-      '.xml',
-    ];
-    return sourceExtensions.includes(ext);
-  }
-
-  private buildFileTree(files: string[]): FileNode {
-    const root: FileNode = {
-      path: this.projectPath,
-      name: this.projectPath.split('/').pop() || 'root',
-      type: 'directory',
-    };
-
-    for (const file of files) {
-      const relativePath = relative(this.projectPath, file);
-      const parts = relativePath.split('/');
-      let current = root;
-
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        const isFile = i === parts.length - 1;
-
-        let child = (current.children || []).find((c) => c.name === part);
-        if (!child) {
-          child = {
-            path: join(current.path, part),
-            name: part,
-            type: isFile ? 'file' : 'directory',
-            extension: isFile ? extname(part) : undefined,
-          };
-
-          if (isFile) {
-            child.lines = this.countLines(file);
-            child.language = this.detectLanguage(file);
-          }
-
-          if (!current.children) current.children = [];
-          current.children.push(child);
-        }
-
-        current = child;
-      }
-    }
-
-    return root;
-  }
-
-  /**
-   * Detect frameworks ONLY from specified package.json files.
-   * Never reads package.json from node_modules.
-   * No string-matching fallback — only structured dependency key detection.
-   */
-  private detectFrameworks(packageJsonPaths: string[]): Set<string> {
-    const frameworks = new Set<string>();
-
-    for (const file of packageJsonPaths) {
-      if (!file.endsWith('package.json')) continue;
-
-      // Safety: skip any path that includes node_modules
-      if (file.includes('node_modules')) continue;
-
-      try {
-        const content = readFileSync(file, 'utf-8');
-        const parsed = JSON.parse(content);
-        const allDeps = {
-          ...parsed.dependencies,
-          ...parsed.devDependencies,
-        };
-
-        // Detect from actual dependency keys — no string fallback
-        if (allDeps['@nestjs/core'] || allDeps['@nestjs/common']) frameworks.add('NestJS');
-        if (allDeps['react'] || allDeps['react-dom']) frameworks.add('React');
-        if (allDeps['@angular/core']) frameworks.add('Angular');
-        if (allDeps['vue'] || allDeps['@vue/core']) frameworks.add('Vue.js');
-        if (allDeps['express']) frameworks.add('Express.js');
-        if (allDeps['next']) frameworks.add('Next.js');
-        if (allDeps['fastify']) frameworks.add('Fastify');
-        if (allDeps['typeorm']) frameworks.add('TypeORM');
-        if (allDeps['prisma'] || allDeps['@prisma/client']) frameworks.add('Prisma');
-        if (allDeps['sequelize']) frameworks.add('Sequelize');
-        if (allDeps['mongoose']) frameworks.add('Mongoose');
-        if (allDeps['@modelcontextprotocol/sdk']) frameworks.add('MCP SDK');
-        if (allDeps['probot']) frameworks.add('Probot');
-        if (allDeps['hono']) frameworks.add('Hono');
-      } catch (error) {
-        logger.debug('Skipping unparseable package.json during framework detection', { file, error });
-      }
-    }
-
-    // Check for pom.xml only at project root
-    const pomPath = join(this.projectPath, 'pom.xml');
-    if (existsSync(pomPath)) {
-      try {
-        const content = readFileSync(pomPath, 'utf-8');
-        if (content.includes('spring-boot')) frameworks.add('Spring Boot');
-        if (content.includes('spring') && !content.includes('spring-boot')) frameworks.add('Spring');
-      } catch (error) {
-        logger.debug('Error reading pom.xml', { error });
-      }
-    }
-
-    // Check for requirements.txt only at project root
-    const reqPath = join(this.projectPath, 'requirements.txt');
-    if (existsSync(reqPath)) {
-      try {
-        const content = readFileSync(reqPath, 'utf-8');
-        if (content.includes('django')) frameworks.add('Django');
-        if (content.includes('flask')) frameworks.add('Flask');
-        if (content.includes('fastapi')) frameworks.add('FastAPI');
-      } catch (error) {
-        logger.debug('Error reading requirements.txt', { error });
-      }
-    }
-
-    // Check for Gemfile only at project root
-    const gemPath = join(this.projectPath, 'Gemfile');
-    if (existsSync(gemPath)) {
-      try {
-        const content = readFileSync(gemPath, 'utf-8');
-        if (content.includes('rails')) frameworks.add('Ruby on Rails');
-      } catch (error) {
-        logger.debug('Error reading Gemfile', { error });
-      }
-    }
-
-    // Check for go.mod only at project root
-    if (existsSync(join(this.projectPath, 'go.mod'))) {
-      frameworks.add('Go');
-    }
-
-    return frameworks;
-  }
-
-  private detectLanguages(files: string[]): string[] {
-    const languages = new Set<string>();
-
-    for (const file of files) {
-      const lang = this.detectLanguage(file);
-      if (lang && lang !== 'Unknown') languages.add(lang);
-    }
-
-    return Array.from(languages);
-  }
-
-  private detectLanguage(filePath: string): string {
-    const ext = extname(filePath).toLowerCase();
-
-    const languageMap: Record<string, string> = {
-      '.js': 'JavaScript',
-      '.ts': 'TypeScript',
-      '.tsx': 'TypeScript',
-      '.jsx': 'JavaScript',
-      '.py': 'Python',
-      '.java': 'Java',
-      '.go': 'Go',
-      '.rb': 'Ruby',
-      '.php': 'PHP',
-      '.cs': 'C#',
-      '.cpp': 'C++',
-      '.c': 'C',
-      '.rs': 'Rust',
-      '.kt': 'Kotlin',
-      '.scala': 'Scala',
-      '.sql': 'SQL',
-      '.graphql': 'GraphQL',
-    };
-
-    return languageMap[ext] || 'Unknown';
-  }
-
-  private countLines(filePath: string): number {
-    try {
-      const content = readFileSync(filePath, 'utf-8');
-      return content.split('\n').length;
-    } catch {
-      return 0;
-    }
-  }
-
-  private countTotalLines(files: string[]): number {
-    return files.reduce((total, file) => total + this.countLines(file), 0);
-  }
-}

package/src/scripts/bundle-deps.js

@@ -1,123 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-const targets = [
-  'scripts/decompose-detectors.ts'
-];
-
-let processed = 0;
-
-for (const target of targets) {
-  const filePath = path.resolve(target);
-  if (!fs.existsSync(filePath)) {
-    console.warn(`File not found: ${target}`);
-    continue;
-  }
-
-  let content = fs.readFileSync(filePath, 'utf8');
-  const importRegex = /^import\s+([^'"]+)\s+from\s+['"]([^'"]+)['"];?/gm;
-  
-  const depsExports = [];
-  const localImports = [];
-  
-  let match;
-  let remainingContent = content;
-
-  // We must process ALL imports from relative local files (starts with '.' or '..')
-  while ((match = importRegex.exec(content)) !== null) {
-    const fullStatement = match[0];
-    const bindingsRaw = match[1].trim();
-    const source = match[2];
-    
-    // Skip absolute module imports like 'fs' or 'path' or 'vitest'
-    if (!source.startsWith('.')) continue;
-
-    // Remove this import statement from original file
-    remainingContent = remainingContent.replace(fullStatement, '');
-
-    // Parse bindings
-    // Cases:
-    // 1. { A, B as C }
-    // 2. defaultExport
-    // 3. * as ns
-    // 4. defaultExport, { A, B }
-    
-    let defaultImport = null;
-    let namedImports = [];
-    let namespaceImport = null;
-
-    if (bindingsRaw.startsWith('* as ')) {
-      namespaceImport = bindingsRaw.substring(5).trim();
-    } else {
-      let rest = bindingsRaw;
-      if (!bindingsRaw.startsWith('{')) {
-        const parts = bindingsRaw.split(',');
-        defaultImport = parts[0].trim();
-        rest = parts.slice(1).join(',').trim();
-      }
-      if (rest.startsWith('{') && rest.endsWith('}')) {
-        const enclosed = rest.slice(1, -1);
-        namedImports = enclosed.split(',').map(s => s.trim()).filter(Boolean);
-      }
-    }
-
-    // Generate exports for _deps.ts
-    // Generate new import names for Original file
-    const exportPieces = [];
-    const importPieces = [];
-
-    if (defaultImport) {
-       exportPieces.push(`default as ${defaultImport}`);
-       importPieces.push(defaultImport);
-    }
-    
-    if (namedImports.length > 0) {
-      const namedStr = namedImports.join(', ');
-      exportPieces.push(namedStr);
-      
-      const localNamesStr = namedImports.map(n => {
-        const asIdx = n.indexOf(' as ');
-        return asIdx !== -1 ? n.substring(asIdx + 4).trim() : n;
-      }).join(', ');
-      
-      importPieces.push(localNamesStr);
-    }
-
-    if (namespaceImport) {
-       depsExports.push(`export * as ${namespaceImport} from '${source}';`);
-       localImports.push(namespaceImport);
-    } else {
-       depsExports.push(`export { ${exportPieces.join(', ')} } from '${source}';`);
-    }
-
-    if (importPieces.length > 0) {
-       localImports.push(...importPieces);
-    }
-  }
-
-  if (depsExports.length > 0) {
-    // Write _deps.ts
-    const ext = path.extname(target);
-    const depsFileRelative = target.replace(ext, '_deps' + ext);
-    const depsFilePath = path.resolve(depsFileRelative);
-    
-    fs.writeFileSync(depsFilePath, depsExports.join('\n') + '\n', 'utf8');
-
-    // Add unified import to original file
-    const newRelativeStr = './' + path.basename(depsFileRelative).replace('.ts', '.js');
-    
-    // Build the final import statement
-    // For simplicity, we just import all locals as named imports from deps?
-    // Wait, some might be default. But _deps re-exports them as named imports! (export { default as Foo })
-    // So the original file just imports { Foo } from './..._deps.js'.
-    const unifiedImportStr = `import { ${localImports.join(', ')} } from '${newRelativeStr}';\n`;
-
-    // Put it at the top
-    remainingContent = unifiedImportStr + '\n' + remainingContent.replace(/^\s+/, '');
-    
-    fs.writeFileSync(filePath, remainingContent, 'utf8');
-    processed++;
-  }
-}
-
-console.log(`Processed ${processed} files and created their _deps equivalents.`);

package/src/scripts/fix-imports.mjs

@@ -1,106 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { globSync } from 'glob';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const rootDir = path.resolve(__dirname, '..'); // project root /src
-
-const files = globSync('**/*.ts', { cwd: rootDir, absolute: true });
-
-// Map from original src path to new src path
-const movedMap = {
-  'analyzer.ts': 'core/analyzer.ts',
-  'anti-patterns.ts': 'core/anti-patterns.ts',
-  'config.ts': 'core/config.ts',
-  'diagram.ts': 'core/diagram.ts',
-  'project-summarizer.ts': 'core/project-summarizer.ts',
-  'refactor-engine.ts': 'core/refactor-engine.ts',
-  'scorer.ts': 'core/scorer.ts',
-  'types.ts': 'core/types.ts',
-  'scanner.ts': 'infrastructure/scanner.ts',
-  'logger.ts': 'infrastructure/logger.ts',
-  'cli.ts': 'adapters/cli.ts',
-  'html-reporter.ts': 'adapters/html-reporter.ts',
-  'refactor-reporter.ts': 'adapters/refactor-reporter.ts',
-  'reporter.ts': 'adapters/reporter.ts',
-  'index.ts': 'core/architect.ts', // old index.ts moved to core/architect.ts
-  'analyzers/git-history.ts': 'infrastructure/git-history.ts',
-  'analyzers/git-cache.ts': 'infrastructure/git-cache.ts',
-  'analyzers/forecast.ts': 'core/analyzers/forecast.ts',
-  'analyzers/temporal-scorer.ts': 'core/analyzers/temporal-scorer.ts',
-  'analyzers/index.ts': 'core/analyzers/index.ts',
-};
-
-function getOldRelPath(newPathRel) {
-  for (const [oldP, newP] of Object.entries(movedMap)) {
-    if (newP === newPathRel) return oldP;
-  }
-  if (newPathRel === 'index.ts') return 'index.ts'; // the newly created index.ts
-  if (newPathRel.startsWith('core/agent-generator/')) return newPathRel.replace('core/', '');
-  if (newPathRel.startsWith('core/rules/')) return newPathRel.replace('core/', '');
-  if (newPathRel.startsWith('core/summarizer/')) return newPathRel.replace('core/', '');
-  if (newPathRel.startsWith('adapters/html-reporter/')) return newPathRel.replace('adapters/', '');
-  return newPathRel; 
-}
-
-function getNewRelPath(oldPathRel) {
-  for (const [oldP, newP] of Object.entries(movedMap)) {
-    if (oldP === oldPathRel) return newP;
-  }
-  if (oldPathRel.startsWith('agent-generator/')) return 'core/' + oldPathRel;
-  if (oldPathRel.startsWith('rules/')) return 'core/' + oldPathRel;
-  if (oldPathRel.startsWith('summarizer/')) return 'core/' + oldPathRel;
-  if (oldPathRel.startsWith('html-reporter/')) return 'adapters/' + oldPathRel;
-  return oldPathRel;
-}
-
-for (const file of files) {
-  if (file.includes('scripts/fix-imports')) continue;
-  
-  const content = fs.readFileSync(file, 'utf-8');
-  const currentNewRel = path.relative(rootDir, file);
-  
-  // What was the old path of this file BEFORE the move?
-  const currentOldRel = getOldRelPath(currentNewRel);
-  
-  let modified = false;
-  
-  const newContent = content.replace(/(from|import)\s+['"]([^'"]+)['"]/g, (match, prefix, importPath) => {
-    // Only process relative imports
-    if (!importPath.startsWith('.')) return match;
-    
-    // JS imports have .js extension. Convert for lookups.
-    const importIsJs = importPath.endsWith('.js');
-    const cleanImportPath = importPath.replace(/\.js$/, '.ts');
-    
-    // 1. Resolve to old absolute path relative to currentOldRel
-    const oldImportAbs = path.resolve(rootDir, path.dirname(currentOldRel), cleanImportPath);
-    const oldImportRel = path.relative(rootDir, oldImportAbs);
-    
-    // 2. Where did this imported file move?
-    const newImportRel = getNewRelPath(oldImportRel);
-    
-    // 3. Calculate new relative import from current file's new location to the new import location
-    let newRelative = path.relative(path.dirname(currentNewRel), newImportRel);
-    if (!newRelative.startsWith('.')) newRelative = './' + newRelative;
-    
-    // 4. Restore the .js extension if it was originally there
-    if (importIsJs) newRelative = newRelative.replace(/\.ts$/, '.js');
-    
-    // Important: DO NOT run math logic if it already has too many parent traverses like `../../../../../` due to double execution!
-    // Since I reset `git clean`, double execution is impossible now.
-    
-    if (newRelative !== importPath) {
-      modified = true;
-      return `${prefix} '${newRelative}'`;
-    }
-    return match;
-  });
-
-  if (modified) {
-    fs.writeFileSync(file, newContent, 'utf-8');
-    console.log(`Updated imports in ${currentNewRel}`);
-  }
-}

package/src/scripts/refactor-imports.js

@@ -1,74 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { globSync } from 'glob';
-
-const typeMap = {
-  StackInfo: "stack.js", FrameworkInfo: "stack.js", DetectedToolchain: "stack.js",
-  DomainInsights: "domain.js", BusinessEntity: "domain.js", ComplianceRequirement: "domain.js", ExternalIntegration: "domain.js", ModuleDetail: "domain.js", DetectedEndpoint: "domain.js",
-  AgentAuditFinding: "agent.js", AgentItemStatus: "agent.js", AgentItem: "agent.js", AgentSuggestion: "agent.js", AgentGeneratorConfig: "agent.js", DEFAULT_AGENT_CONFIG: "agent.js",
-  TemplateContext: "template.js", EnrichedTemplateContext: "template.js"
-};
-
-const files = globSync('src/**/*.ts');
-let updated = 0;
-
-for (const file of files) {
-  let content = fs.readFileSync(file, 'utf8');
-  let original = content;
-  
-  const regex = /import\s+{([^}]+)}\s+from\s+['"]([^'"]+)['"];/g;
-  const matches = [...content.matchAll(regex)];
-  
-  for (const m of matches) {
-    if (!m[2].endsWith('types.js')) continue;
-    
-    // Check if the expected absolute path is src/core/agent-generator/types.js
-    const baseDir = path.dirname(file);
-    const absPath = path.resolve(baseDir, m[2]);
-    const expected = path.resolve('src/core/agent-generator/types.js');
-    if (absPath !== expected) continue;
-    
-    const items = m[1].split(',').map(i => i.trim()).filter(Boolean);
-    const grouped = {};
-    for (const item of items) {
-      if (item === 'AnalysisReport' || item === 'RefactoringPlan') {
-         // These were falsely imported from agent-generator/types.ts sometimes? actually wait!
-         // agent-generator/types.ts didn't export AnalysisReport. They probably import it from parent.
-         continue; // Wait, actually if they imported from expected, they shouldn't have AnalysisReport unless they imported it from core/types.js.
-      }
-      const dest = typeMap[item];
-      if (!dest) {
-         console.warn(`WARNING Unknown entity: ${item} in ${file}`);
-         continue;
-      }
-      if (!grouped[dest]) grouped[dest] = [];
-      grouped[dest].push(item);
-    }
-    
-    // If we matched something but nothing could be placed in grouped, we continue.
-    if (Object.keys(grouped).length === 0) continue;
-
-    const newStatements = [];
-    for (const dest of Object.keys(grouped)) {
-      const newTarget = path.resolve('src/core/agent-generator/types', dest);
-      let newRel = path.relative(baseDir, newTarget);
-      if (!newRel.startsWith('.')) newRel = './' + newRel;
-      newStatements.push(`import { ${grouped[dest].join(', ')} } from '${newRel}';`);
-    }
-    
-    // Ensure we keep stuff we ignored (if it was an ad-hoc import not matching the map).
-    const ignoredItems = items.filter(i => !typeMap[i]);
-    if (ignoredItems.length > 0) {
-      // It shouldn't be mapped here because it was an error in original file, but we preserve it just in case
-      newStatements.push(`import { ${ignoredItems.join(', ')} } from '${m[2]}';`);
-    }
-    
-    content = content.replace(m[0], newStatements.join('\n'));
-  }
-  
-  if (content !== original) {
-    fs.writeFileSync(file, content);
-    updated++;
-  }
-}
-console.log(`Updated ${updated} files`);

package/src/scripts/refactor-utils.js

@@ -1,23 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { globSync } from 'glob';
-
-// 1. html-reporter.ts
-{
-  const file = 'src/adapters/html-reporter.ts';
-  let content = fs.readFileSync(file, 'utf8');
-  content = content.replace(/"\.\/html-reporter\/utils\.js"/g, '"./html-reporter/utils_adapters.js"');
-  fs.writeFileSync(file, content);
-}
-
-// 2. sections/*.ts
-{
-  const files = globSync('src/adapters/html-reporter/sections/*.ts');
-  for (const file of files) {
-    let content = fs.readFileSync(file, 'utf8');
-    content = content.replace(/"\.\.\/utils\.js"/g, '"../utils_sections.js"');
-    fs.writeFileSync(file, content);
-  }
-}
-
-console.log('Rewired utils for 9 files successfully.');

package/test-shotgun.js

@@ -1,7 +0,0 @@
-import { readFileSync } from 'fs';
-import { architect } from './dist/core/architect.js';
-(async () => {
-  const report = await architect.analyze('.');
-  const patterns = report.antiPatterns.filter(p => p.name === 'Shotgun Surgery');
-  patterns.forEach(p => console.log(p.location));
-})();