agentsys 5.0.3 → 5.1.0

package/plugins/debate/lib/adapter-transforms.js

@@ -0,0 +1,298 @@
+/**
+ * Adapter Transform Functions
+ *
+ * Shared transforms for converting Claude Code plugin content into
+ * OpenCode and Codex adapter formats. Used by:
+ *   - bin/cli.js (npm installer)
+ *   - scripts/dev-install.js (development installer)
+ *   - scripts/gen-adapters.js (static adapter generation)
+ *
+ * @module adapter-transforms
+ * @author Avi Fenesh
+ * @license MIT
+ */
+
+const discovery = require('./discovery');
+
+function transformBodyForOpenCode(content, repoRoot) {
+  content = content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, '${PLUGIN_ROOT}');
+  content = content.replace(/\$CLAUDE_PLUGIN_ROOT/g, '$PLUGIN_ROOT');
+
+  // Replace .claude/ paths with .opencode/ but preserve platform documentation lists
+  // that enumerate all three platforms (Claude Code: .claude/, OpenCode: .opencode/, Codex: .codex/)
+  // Also preserve {AI_STATE_DIR} references which are platform-agnostic
+  content = content.replace(/\.claude\//g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    // Skip if inside a platform enumeration (e.g., "Claude Code: `.claude/`")
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode/';
+  });
+  content = content.replace(/\.claude'/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return ".opencode'";
+  });
+  content = content.replace(/\.claude"/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode"';
+  });
+  content = content.replace(/\.claude`/g, (match, offset) => {
+    const context = content.substring(Math.max(0, offset - 60), offset + match.length + 10);
+    if (/Claude Code:/.test(context)) return match;
+    return '.opencode`';
+  });
+
+  const plugins = discovery.discoverPlugins(repoRoot);
+  if (plugins.length > 0) {
+    const pluginNames = plugins.join('|');
+    content = content.replace(new RegExp('`(' + pluginNames + '):([a-z-]+)`', 'g'), '`$2`');
+    content = content.replace(new RegExp('(' + pluginNames + '):([a-z-]+)', 'g'), '$2');
+  }
+
+  content = content.replace(
+    /```(\w*)\n([\s\S]*?)```/g,
+    (match, lang, code) => {
+      const langLower = (lang || '').toLowerCase();
+
+      if (langLower === 'bash' || langLower === 'shell' || langLower === 'sh') {
+        if (code.includes('node -e') && code.includes('require(')) {
+          return '*(Bash command with Node.js require - adapt for OpenCode)*';
+        }
+        return match;
+      }
+
+      if (!lang && (code.trim().startsWith('gh ') || code.trim().startsWith('glab ') ||
+          code.trim().startsWith('git ') || code.trim().startsWith('#!'))) {
+        return match;
+      }
+
+      if (code.includes('require(') || code.includes('Task(') ||
+          code.includes('const ') || code.includes('let ') ||
+          code.includes('function ') || code.includes('=>') ||
+          code.includes('async ') || code.includes('await ')) {
+
+        let instructions = '';
+
+        const taskMatches = [...code.matchAll(/(?:await\s+)?Task\s*\(\s*\{[^}]*subagent_type:\s*["'](?:[^"':]+:)?([^"']+)["'][^}]*\}\s*\)/gs)];
+        for (const taskMatch of taskMatches) {
+          const agent = taskMatch[1];
+          instructions += `- Invoke \`@${agent}\` agent\n`;
+        }
+
+        const phaseMatches = code.match(/startPhase\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+        if (phaseMatches) {
+          for (const pm of phaseMatches) {
+            const phase = pm.match(/['"]([^'"]+)['"]/)[1];
+            instructions += `- Phase: ${phase}\n`;
+          }
+        }
+
+        if (code.includes('AskUserQuestion')) {
+          instructions += '- Use AskUserQuestion tool for user input\n';
+        }
+
+        if (code.includes('EnterPlanMode')) {
+          instructions += '- Use EnterPlanMode for user approval\n';
+        }
+
+        if (instructions) {
+          return instructions;
+        }
+
+        return '*(JavaScript reference - not executable in OpenCode)*';
+      }
+
+      return match;
+    }
+  );
+
+  content = content.replace(/\*\(Reference - adapt for OpenCode\)\*/g, '');
+
+  content = content.replace(/await\s+Task\s*\(\s*\{[\s\S]*?\}\s*\);?/g, (match) => {
+    const agentMatch = match.match(/subagent_type:\s*["'](?:[^"':]+:)?([^"']+)["']/);
+    if (agentMatch) {
+      return `Invoke \`@${agentMatch[1]}\` agent`;
+    }
+    return '*(Task call - use @agent-name syntax)*';
+  });
+
+  content = content.replace(/(?:const|let|var)\s+\{?[^}=\n]+\}?\s*=\s*require\s*\([^)]+\);?/g, '');
+  content = content.replace(/require\s*\(['"][^'"]+['"]\)/g, '');
+
+  if (content.includes('agent')) {
+    const note = `
+> **OpenCode Note**: Invoke agents using \`@agent-name\` syntax.
+> Available agents: task-discoverer, exploration-agent, planning-agent,
+> implementation-agent, deslop-agent, delivery-validator, sync-docs-agent, consult-agent
+> Example: \`@exploration-agent analyze the codebase\`
+
+`;
+    content = content.replace(/^(---\n[\s\S]*?---\n)/, `$1${note}`);
+  }
+
+  if (content.includes('Master Workflow Orchestrator') && content.includes('No Shortcuts Policy')) {
+    const policySection = `
+## Phase 1: Policy Selection (Built-in Options)
+
+Ask the user these questions using AskUserQuestion:
+
+**Question 1 - Source**: "Where should I look for tasks?"
+- GitHub Issues - Use \`gh issue list\` to find issues
+- GitLab Issues - Use \`glab issue list\` to find issues
+- Local tasks.md - Read from PLAN.md, tasks.md, or TODO.md in the repo
+- Custom - User specifies their own source
+- Other - User describes source, you figure it out
+
+**Question 2 - Priority**: "What type of tasks to prioritize?"
+- All - Consider all tasks, pick by score
+- Bugs - Focus on bug fixes
+- Security - Security issues first
+- Features - New feature development
+
+**Question 3 - Stop Point**: "How far should I take this task?"
+- Merged - Until PR is merged to main
+- PR Created - Stop after creating PR
+- Implemented - Stop after local implementation
+- Deployed - Deploy to staging
+- Production - Full production deployment
+
+After user answers, proceed to Phase 2 with the selected policy.
+
+`;
+    if (content.includes('OpenCode Note')) {
+      content = content.replace(/(Example:.*analyze the codebase\`\n\n)/, `$1${policySection}`);
+    }
+  }
+
+  return content;
+}
+
+function transformCommandFrontmatterForOpenCode(content) {
+  return content.replace(
+    /^---\n([\s\S]*?)^---/m,
+    (match, frontmatter) => {
+      // Parse existing frontmatter
+      const lines = frontmatter.trim().split('\n');
+      const parsed = {};
+      for (const line of lines) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx > 0) {
+          const key = line.substring(0, colonIdx).trim();
+          const value = line.substring(colonIdx + 1).trim();
+          parsed[key] = value;
+        }
+      }
+
+      // Build OpenCode command frontmatter
+      let opencodeFrontmatter = '---\n';
+      if (parsed.description) opencodeFrontmatter += `description: ${parsed.description}\n`;
+      opencodeFrontmatter += 'agent: general\n';
+      // Don't include argument-hint or allowed-tools (not supported)
+      opencodeFrontmatter += '---';
+      return opencodeFrontmatter;
+    }
+  );
+}
+
+function transformAgentFrontmatterForOpenCode(content, options) {
+  const { stripModels = true } = options || {};
+
+  return content.replace(
+    /^---\n([\s\S]*?)^---/m,
+    (match, frontmatter) => {
+      // Parse existing frontmatter
+      const lines = frontmatter.trim().split('\n');
+      const parsed = {};
+      for (const line of lines) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx > 0) {
+          const key = line.substring(0, colonIdx).trim();
+          const value = line.substring(colonIdx + 1).trim();
+          parsed[key] = value;
+        }
+      }
+
+      // Build OpenCode frontmatter
+      let opencodeFrontmatter = '---\n';
+      if (parsed.name) opencodeFrontmatter += `name: ${parsed.name}\n`;
+      if (parsed.description) opencodeFrontmatter += `description: ${parsed.description}\n`;
+      opencodeFrontmatter += 'mode: subagent\n';
+
+      // Map model names - only include if NOT stripping
+      if (parsed.model && !stripModels) {
+        const modelMap = {
+          'sonnet': 'anthropic/claude-sonnet-4',
+          'opus': 'anthropic/claude-opus-4',
+          'haiku': 'anthropic/claude-haiku-3-5'
+        };
+        opencodeFrontmatter += `model: ${modelMap[parsed.model] || parsed.model}\n`;
+      }
+
+      // Convert tools to permissions
+      if (parsed.tools) {
+        opencodeFrontmatter += 'permission:\n';
+        const tools = parsed.tools.toLowerCase();
+        opencodeFrontmatter += `  read: ${tools.includes('read') ? 'allow' : 'deny'}\n`;
+        opencodeFrontmatter += `  edit: ${tools.includes('edit') || tools.includes('write') ? 'allow' : 'deny'}\n`;
+        opencodeFrontmatter += `  bash: ${tools.includes('bash') ? 'allow' : 'ask'}\n`;
+        opencodeFrontmatter += `  glob: ${tools.includes('glob') ? 'allow' : 'deny'}\n`;
+        opencodeFrontmatter += `  grep: ${tools.includes('grep') ? 'allow' : 'deny'}\n`;
+      }
+
+      opencodeFrontmatter += '---';
+      return opencodeFrontmatter;
+    }
+  );
+}
+
+function transformSkillBodyForOpenCode(content, repoRoot) {
+  return transformBodyForOpenCode(content, repoRoot);
+}
+
+function transformForCodex(content, options) {
+  const { skillName, description, pluginInstallPath } = options;
+
+  // Escape description for YAML: wrap in double quotes, escape backslashes and internal quotes
+  const escapedDescription = description.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const yamlDescription = `"${escapedDescription}"`;
+
+  if (content.startsWith('---')) {
+    // Replace existing frontmatter with Codex-compatible format
+    content = content.replace(
+      /^---\n[\s\S]*?\n---\n/,
+      `---\nname: ${skillName}\ndescription: ${yamlDescription}\n---\n`
+    );
+  } else {
+    // Add new frontmatter
+    content = `---\nname: ${skillName}\ndescription: ${yamlDescription}\n---\n\n${content}`;
+  }
+
+  // Transform PLUGIN_ROOT to actual installed path (or placeholder) for Codex
+  content = content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginInstallPath);
+  content = content.replace(/\$CLAUDE_PLUGIN_ROOT/g, pluginInstallPath);
+  content = content.replace(/\$\{PLUGIN_ROOT\}/g, pluginInstallPath);
+  content = content.replace(/\$PLUGIN_ROOT/g, pluginInstallPath);
+
+  // Transform AskUserQuestion → request_user_input for Codex native tool
+  content = content.replace(/AskUserQuestion/g, 'request_user_input');
+
+  // Remove multiSelect lines (not supported in Codex)
+  content = content.replace(/^[ \t]*multiSelect:.*\n?/gm, '');
+
+  // Inject Codex note about required id field after request_user_input blocks
+  content = content.replace(
+    /^([ \t]*request_user_input:\s*)$/gm,
+    '$1\n> **Codex**: Each question MUST include a unique `id` field (e.g., `id: "q1"`).'
+  );
+
+  return content;
+}
+
+module.exports = {
+  transformBodyForOpenCode,
+  transformCommandFrontmatterForOpenCode,
+  transformAgentFrontmatterForOpenCode,
+  transformSkillBodyForOpenCode,
+  transformForCodex
+};

package/plugins/debate/lib/collectors/codebase.js

@@ -0,0 +1,392 @@
+/**
+ * Codebase Collector
+ *
+ * Scans codebase structure, frameworks, and implemented features.
+ * Extracted from drift-detect/collectors.js for shared use.
+ *
+ * @module lib/collectors/codebase
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_OPTIONS = {
+  depth: 'thorough',
+  cwd: process.cwd()
+};
+
+/**
+ * Maximum file size to analyze (50KB)
+ * Larger files are skipped to avoid memory issues
+ */
+const MAX_FILE_SIZE = 50000;
+
+/**
+ * Directories to exclude from analysis
+ */
+const EXCLUDE_DIRS = [
+  'node_modules', 'vendor', 'dist', 'build', 'out', 'target',
+  '.git', '.svn', '.hg', '__pycache__', '.pytest_cache',
+  'coverage', '.nyc_output', '.next', '.nuxt', '.cache'
+];
+
+/**
+ * Source file extensions per language
+ */
+const SOURCE_EXTENSIONS = {
+  js: ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'],
+  rust: ['.rs'],
+  go: ['.go'],
+  python: ['.py'],
+  java: ['.java']
+};
+
+/**
+ * Safe file read
+ */
+function safeReadFile(filePath, basePath) {
+  const fullPath = path.resolve(basePath, filePath);
+  const resolvedBase = path.resolve(basePath);
+  if (!fullPath.startsWith(resolvedBase)) {
+    return null;
+  }
+  try {
+    return fs.readFileSync(fullPath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if path should be excluded
+ */
+function shouldExclude(filePath, excludeDirs = EXCLUDE_DIRS) {
+  const parts = filePath.split(/[\\/]/);
+  return parts.some(part => excludeDirs.includes(part));
+}
+
+/**
+ * Detect frameworks from package.json
+ */
+function detectFrameworks(result, pkgJson) {
+  const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+  const frameworkMap = {
+    react: 'React',
+    'react-dom': 'React',
+    next: 'Next.js',
+    vue: 'Vue.js',
+    nuxt: 'Nuxt',
+    angular: 'Angular',
+    express: 'Express',
+    fastify: 'Fastify',
+    koa: 'Koa',
+    nestjs: 'NestJS'
+  };
+
+  for (const [pkgName, framework] of Object.entries(frameworkMap)) {
+    if (deps[pkgName]) {
+      result.frameworks.push(framework);
+    }
+  }
+
+  result.frameworks = [...new Set(result.frameworks)];
+}
+
+/**
+ * Detect test framework
+ */
+function detectTestFramework(result, pkgJson) {
+  const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+  const testFrameworks = ['jest', 'mocha', 'vitest', 'ava', 'tap', 'jasmine'];
+
+  for (const framework of testFrameworks) {
+    if (deps[framework]) {
+      result.testFramework = framework;
+      result.health.hasTests = true;
+      break;
+    }
+  }
+}
+
+/**
+ * Extract symbols (functions, classes, exports) from a JS/TS file
+ */
+function extractSymbols(content) {
+  const symbols = {
+    functions: [],
+    classes: [],
+    exports: []
+  };
+
+  const funcPattern = /(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+  let match;
+  while ((match = funcPattern.exec(content)) !== null) {
+    symbols.functions.push(match[1]);
+  }
+
+  const arrowPattern = /(?:const|let)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g;
+  while ((match = arrowPattern.exec(content)) !== null) {
+    symbols.functions.push(match[1]);
+  }
+
+  const classPattern = /class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+  while ((match = classPattern.exec(content)) !== null) {
+    symbols.classes.push(match[1]);
+  }
+
+  const namedExportPattern = /export\s+(?:(?:async\s+)?function|class|const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
+  while ((match = namedExportPattern.exec(content)) !== null) {
+    symbols.exports.push(match[1]);
+  }
+
+  const moduleExportsPattern = /module\.exports\s*=\s*\{([^}]+)\}/;
+  const moduleMatch = content.match(moduleExportsPattern);
+  if (moduleMatch) {
+    const keys = moduleMatch[1].split(',').map(k => k.trim().split(':')[0].trim());
+    symbols.exports.push(...keys.filter(k => k && /^[a-zA-Z_$]/.test(k)));
+  }
+
+  symbols.functions = [...new Set(symbols.functions)];
+  symbols.classes = [...new Set(symbols.classes)];
+  symbols.exports = [...new Set(symbols.exports)];
+
+  return symbols;
+}
+
+/**
+ * Scan key source files for symbols
+ */
+function scanFileSymbols(basePath, topLevelDirs) {
+  const sourceSymbols = {};
+  const sourceDirs = ['lib', 'src', 'app', 'pages', 'components', 'utils', 'services', 'api'];
+  const dirsToScan = topLevelDirs.filter(d => sourceDirs.includes(d));
+  const allExts = Object.values(SOURCE_EXTENSIONS).flat();
+
+  let filesScanned = 0;
+  const maxFiles = 40;
+
+  function scanDir(dirPath, relativePath, depth = 0) {
+    if (filesScanned >= maxFiles || depth > 2) return;
+    if (!fs.existsSync(dirPath)) return;
+
+    try {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (filesScanned >= maxFiles) break;
+
+        const fullPath = path.join(dirPath, entry.name);
+        const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+
+        if (entry.isDirectory()) {
+          if (['node_modules', '__tests__', 'test', 'tests', 'dist', 'build'].includes(entry.name)) continue;
+          scanDir(fullPath, relPath, depth + 1);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (!allExts.includes(ext)) continue;
+          if (entry.name.includes('.test.') || entry.name.includes('.spec.')) continue;
+
+          try {
+            const stat = fs.statSync(fullPath);
+            if (stat.size > MAX_FILE_SIZE) continue;
+
+            const content = fs.readFileSync(fullPath, 'utf8');
+            const symbols = extractSymbols(content);
+
+            if (symbols.functions.length || symbols.classes.length || symbols.exports.length) {
+              sourceSymbols[relPath] = symbols;
+              filesScanned++;
+            }
+          } catch {
+            // Skip unreadable files
+          }
+        }
+      }
+    } catch {
+      // Skip unreadable dirs
+    }
+  }
+
+  for (const dir of dirsToScan) {
+    if (filesScanned >= maxFiles) break;
+    scanDir(path.join(basePath, dir), dir);
+  }
+
+  return sourceSymbols;
+}
+
+/**
+ * Scan directory structure recursively
+ */
+function scanDirectory(result, basePath, relativePath, maxDepth, depth = 0) {
+  if (depth >= maxDepth) return;
+
+  const fullPath = path.join(basePath, relativePath);
+  if (!fs.existsSync(fullPath)) return;
+
+  try {
+    const entries = fs.readdirSync(fullPath, { withFileTypes: true });
+    const dirs = [];
+    const files = [];
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!EXCLUDE_DIRS.includes(entry.name)) {
+          dirs.push(entry.name);
+        }
+      } else {
+        files.push(entry.name);
+      }
+    }
+
+    const key = relativePath || '.';
+    result.structure[key] = { dirs, fileCount: files.length };
+
+    for (const file of files) {
+      const ext = path.extname(file).toLowerCase() || 'no-ext';
+      result.fileStats[ext] = (result.fileStats[ext] || 0) + 1;
+    }
+
+    for (const dir of dirs) {
+      scanDirectory(result, basePath, path.join(relativePath, dir), maxDepth, depth + 1);
+    }
+  } catch {
+    // Permission or read errors
+  }
+}
+
+/**
+ * Detect project health indicators
+ */
+function detectHealth(result, basePath) {
+  result.health.hasReadme = fs.existsSync(path.join(basePath, 'README.md'));
+
+  const lintConfigs = ['.eslintrc', '.eslintrc.js', '.eslintrc.json', 'eslint.config.js', 'biome.json'];
+  result.health.hasLinting = lintConfigs.some(f => fs.existsSync(path.join(basePath, f)));
+
+  const ciConfigs = [
+    '.github/workflows',
+    '.gitlab-ci.yml',
+    '.circleci',
+    'Jenkinsfile',
+    '.travis.yml'
+  ];
+  result.health.hasCi = ciConfigs.some(f => fs.existsSync(path.join(basePath, f)));
+
+  const testDirs = ['tests', '__tests__', 'test', 'spec'];
+  result.health.hasTests = result.health.hasTests || testDirs.some(d => fs.existsSync(path.join(basePath, d)));
+}
+
+/**
+ * Find implemented features from code patterns
+ */
+function findImplementedFeatures(result, basePath) {
+  const featurePatterns = {
+    authentication: ['auth', 'login', 'session', 'jwt', 'oauth'],
+    api: ['routes', 'controllers', 'handlers', 'endpoints'],
+    database: ['models', 'schemas', 'migrations', 'seeds'],
+    ui: ['components', 'views', 'pages', 'layouts'],
+    testing: ['__tests__', 'test', 'spec', '.test.', '.spec.'],
+    docs: ['docs', 'documentation', 'wiki']
+  };
+
+  for (const [feature, patterns] of Object.entries(featurePatterns)) {
+    const found = patterns.some(pattern => {
+      for (const dir of Object.keys(result.structure)) {
+        if (dir.toLowerCase().includes(pattern)) {
+          return true;
+        }
+      }
+      return false;
+    });
+
+    if (found) {
+      result.implementedFeatures.push(feature);
+    }
+  }
+}
+
+/**
+ * Scan codebase structure and features
+ * @param {Object} options - Collection options
+ * @returns {Object} Codebase analysis
+ */
+function scanCodebase(options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const basePath = opts.cwd;
+
+  const result = {
+    summary: { totalDirs: 0, totalFiles: 0 },
+    topLevelDirs: [],
+    frameworks: [],
+    testFramework: null,
+    hasTypeScript: false,
+    implementedFeatures: [],
+    symbols: {},
+    health: {
+      hasTests: false,
+      hasLinting: false,
+      hasCi: false,
+      hasReadme: false
+    },
+    fileStats: {}
+  };
+
+  const internalStructure = {};
+
+  // Detect package.json dependencies
+  const pkgContent = safeReadFile('package.json', basePath);
+  if (pkgContent) {
+    try {
+      const pkg = JSON.parse(pkgContent);
+      detectFrameworks(result, pkg);
+      detectTestFramework(result, pkg);
+    } catch {
+      // Invalid JSON
+    }
+  }
+
+  result.hasTypeScript = fs.existsSync(path.join(basePath, 'tsconfig.json'));
+
+  scanDirectory({ structure: internalStructure, fileStats: result.fileStats }, basePath, '', opts.depth === 'thorough' ? 3 : 2);
+
+  result.summary.totalDirs = Object.keys(internalStructure).length;
+  result.summary.totalFiles = Object.values(internalStructure).reduce((sum, d) => sum + (d.fileCount || 0), 0);
+
+  const rootEntry = internalStructure['.'];
+  if (rootEntry) {
+    result.topLevelDirs = rootEntry.dirs || [];
+  }
+
+  detectHealth(result, basePath);
+
+  if (opts.depth === 'thorough') {
+    findImplementedFeatures({ ...result, structure: internalStructure }, basePath);
+    result.symbols = scanFileSymbols(basePath, result.topLevelDirs);
+  }
+
+  const sortedStats = Object.entries(result.fileStats)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10);
+  result.fileStats = Object.fromEntries(sortedStats);
+
+  return result;
+}
+
+module.exports = {
+  DEFAULT_OPTIONS,
+  EXCLUDE_DIRS,
+  SOURCE_EXTENSIONS,
+  scanCodebase,
+  detectFrameworks,
+  detectTestFramework,
+  detectHealth,
+  findImplementedFeatures,
+  extractSymbols,
+  scanFileSymbols,
+  scanDirectory,
+  shouldExclude,
+  safeReadFile
+};