@ai-sdlc/orchestrator 0.1.0

package/dist/analysis/convention-detector.js

@@ -0,0 +1,177 @@
+/**
+ * Detect coding conventions: naming style, test organization, import style.
+ */
+import { basename, dirname, extname } from 'node:path';
+// ── Naming style helpers ──────────────────────────────────────────
+function isCamelCase(name) {
+    return /^[a-z][a-zA-Z0-9]*$/.test(name);
+}
+function isPascalCase(name) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+function isKebabCase(name) {
+    return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(name);
+}
+function isSnakeCase(name) {
+    return /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/.test(name);
+}
+function detectFileNamingStyle(files) {
+    const counts = {
+        camelCase: 0,
+        PascalCase: 0,
+        'kebab-case': 0,
+        snake_case: 0,
+        mixed: 0,
+    };
+    const examples = {
+        camelCase: [],
+        PascalCase: [],
+        'kebab-case': [],
+        snake_case: [],
+        mixed: [],
+    };
+    for (const file of files) {
+        const name = basename(file.relativePath, extname(file.relativePath)).replace(/\.(test|spec|stories|d)$/, ''); // Strip test/spec suffixes
+        if (!name || name === 'index')
+            continue;
+        if (isKebabCase(name)) {
+            counts['kebab-case']++;
+            if (examples['kebab-case'].length < 3)
+                examples['kebab-case'].push(file.relativePath);
+        }
+        else if (isSnakeCase(name)) {
+            counts.snake_case++;
+            if (examples.snake_case.length < 3)
+                examples.snake_case.push(file.relativePath);
+        }
+        else if (isCamelCase(name)) {
+            counts.camelCase++;
+            if (examples.camelCase.length < 3)
+                examples.camelCase.push(file.relativePath);
+        }
+        else if (isPascalCase(name)) {
+            counts.PascalCase++;
+            if (examples.PascalCase.length < 3)
+                examples.PascalCase.push(file.relativePath);
+        }
+    }
+    const total = Object.values(counts).reduce((a, b) => a + b, 0);
+    if (total === 0)
+        return { style: 'mixed', confidence: 0, examples: [] };
+    const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+    const [topStyle, topCount] = sorted[0];
+    const confidence = topCount / total;
+    return {
+        style: confidence >= 0.5 ? topStyle : 'mixed',
+        confidence: Math.round(confidence * 100) / 100,
+        examples: examples[topStyle],
+    };
+}
+function detectTestingStyle(files) {
+    let coLocated = 0;
+    let testsDir = 0;
+    let testDir = 0;
+    const examples = {
+        'co-located': [],
+        __tests__: [],
+        'test-directory': [],
+        mixed: [],
+    };
+    const testFiles = files.filter((f) => {
+        const name = basename(f.relativePath);
+        return (name.includes('.test.') || name.includes('.spec.') || f.relativePath.includes('__tests__'));
+    });
+    for (const file of testFiles) {
+        const dir = dirname(file.relativePath);
+        if (dir.includes('__tests__')) {
+            testsDir++;
+            if (examples.__tests__.length < 3)
+                examples.__tests__.push(file.relativePath);
+        }
+        else if (dir === 'test' ||
+            dir === 'tests' ||
+            dir.startsWith('test/') ||
+            dir.startsWith('tests/')) {
+            testDir++;
+            if (examples['test-directory'].length < 3)
+                examples['test-directory'].push(file.relativePath);
+        }
+        else {
+            coLocated++;
+            if (examples['co-located'].length < 3)
+                examples['co-located'].push(file.relativePath);
+        }
+    }
+    const total = coLocated + testsDir + testDir;
+    if (total === 0)
+        return { style: 'mixed', confidence: 0, examples: [] };
+    const counts = { 'co-located': coLocated, __tests__: testsDir, 'test-directory': testDir };
+    const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+    const [topStyle, topCount] = sorted[0];
+    const confidence = topCount / total;
+    return {
+        style: confidence >= 0.5 ? topStyle : 'mixed',
+        confidence: Math.round(confidence * 100) / 100,
+        examples: examples[topStyle],
+    };
+}
+function detectImportStyle(files) {
+    // Check for barrel index files
+    const indexFiles = files.filter((f) => basename(f.relativePath).startsWith('index.'));
+    const usesBarrels = indexFiles.length > 3;
+    // For a proper import analysis we'd need to read file contents,
+    // but for the convention detector we just note barrel presence
+    return {
+        style: 'relative',
+        confidence: 0.8,
+        usesBarrels,
+        examples: indexFiles.slice(0, 3).map((f) => f.relativePath),
+    };
+}
+// ── Public API ──────────────────────────────────────────────────
+/**
+ * Detect coding conventions from the file list.
+ */
+export function detectConventions(files) {
+    const conventions = [];
+    // File naming convention
+    const naming = detectFileNamingStyle(files);
+    if (naming.confidence > 0) {
+        conventions.push({
+            category: 'naming',
+            pattern: `${naming.style} for file names`,
+            confidence: naming.confidence,
+            examples: naming.examples,
+        });
+    }
+    // Testing convention
+    const testing = detectTestingStyle(files);
+    if (testing.confidence > 0) {
+        const desc = testing.style === 'co-located'
+            ? 'Co-located test files (*.test.ts)'
+            : testing.style === '__tests__'
+                ? 'Test files in __tests__/ directories'
+                : testing.style === 'test-directory'
+                    ? 'Test files in test/ directory'
+                    : 'Mixed test file placement';
+        conventions.push({
+            category: 'testing',
+            pattern: desc,
+            confidence: testing.confidence,
+            examples: testing.examples,
+        });
+    }
+    // Import style convention
+    const imports = detectImportStyle(files);
+    const importDesc = imports.usesBarrels
+        ? 'Relative imports, barrel re-exports via index.ts'
+        : 'Relative imports';
+    conventions.push({
+        category: 'imports',
+        pattern: importDesc,
+        confidence: imports.confidence,
+        examples: imports.examples,
+    });
+    return conventions;
+}
+//# sourceMappingURL=convention-detector.js.map

package/dist/analysis/dependency-parser.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Parse TS/JS imports via regex, build module dependency graph, detect cycles.
+ * Uses regex rather than AST for speed and zero external dependencies.
+ */
+import type { ImportStatement, ModuleInfo, ModuleGraph } from './types.js';
+/**
+ * Parse all import/export/require statements from a single file.
+ */
+export declare function parseImports(filePath: string): Promise<ImportStatement[]>;
+/**
+ * Build a module dependency graph from file-level imports.
+ */
+export declare function buildModuleGraph(files: {
+    path: string;
+    relativePath: string;
+}[], modules: ModuleInfo[], rootDir: string): Promise<ModuleGraph>;
+//# sourceMappingURL=dependency-parser.d.ts.map

package/dist/analysis/dependency-parser.js

@@ -0,0 +1,167 @@
+/**
+ * Parse TS/JS imports via regex, build module dependency graph, detect cycles.
+ * Uses regex rather than AST for speed and zero external dependencies.
+ */
+import { readFile } from 'node:fs/promises';
+import { dirname, relative, resolve } from 'node:path';
+// Matches: import ... from 'specifier'  |  import 'specifier'
+const IMPORT_FROM_RE = /import\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+// Matches: export ... from 'specifier'
+const EXPORT_FROM_RE = /export\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+// Matches: require('specifier')
+const REQUIRE_RE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+function isExternal(specifier) {
+    return !specifier.startsWith('.') && !specifier.startsWith('/');
+}
+/**
+ * Parse all import/export/require statements from a single file.
+ */
+export async function parseImports(filePath) {
+    let content;
+    try {
+        content = await readFile(filePath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const imports = [];
+    // Track which specifiers we've already seen to avoid duplicates from re-exports
+    const seen = new Set();
+    for (const regex of [IMPORT_FROM_RE, EXPORT_FROM_RE, REQUIRE_RE]) {
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const specifier = match[1];
+            if (seen.has(specifier))
+                continue;
+            seen.add(specifier);
+            // Find approximate line number
+            const upToMatch = content.slice(0, match.index);
+            const line = upToMatch.split('\n').length;
+            imports.push({
+                source: filePath,
+                specifier,
+                isExternal: isExternal(specifier),
+                line,
+            });
+        }
+    }
+    return imports;
+}
+/**
+ * Resolve a relative import specifier to a module path.
+ * Returns the module directory relative to rootDir, or null if external.
+ */
+function resolveToModule(sourceFile, specifier, rootDir, modulePaths) {
+    if (isExternal(specifier))
+        return null;
+    const sourceDir = dirname(sourceFile);
+    const resolved = resolve(sourceDir, specifier);
+    const relResolved = relative(rootDir, resolved).split('\\').join('/');
+    // Walk up from the resolved path to find the containing module
+    const parts = relResolved.split('/');
+    for (let i = parts.length; i > 0; i--) {
+        const candidate = parts.slice(0, i).join('/');
+        if (modulePaths.has(candidate))
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Build a module dependency graph from file-level imports.
+ */
+export async function buildModuleGraph(files, modules, rootDir) {
+    const modulePaths = new Set(modules.map((m) => m.path));
+    const edgeMap = new Map();
+    const externalDeps = new Set();
+    for (const file of files) {
+        const imports = await parseImports(file.path);
+        // Determine which module this file belongs to
+        const relParts = file.relativePath.split('/');
+        let sourceModule = null;
+        for (let i = relParts.length; i > 0; i--) {
+            const candidate = relParts.slice(0, i).join('/');
+            if (modulePaths.has(candidate)) {
+                sourceModule = candidate;
+                break;
+            }
+        }
+        for (const imp of imports) {
+            if (imp.isExternal) {
+                // Extract package name (handle scoped packages)
+                const pkgName = imp.specifier.startsWith('@')
+                    ? imp.specifier.split('/').slice(0, 2).join('/')
+                    : imp.specifier.split('/')[0];
+                externalDeps.add(pkgName);
+                continue;
+            }
+            if (!sourceModule)
+                continue;
+            const targetModule = resolveToModule(file.path, imp.specifier, rootDir, modulePaths);
+            if (targetModule && targetModule !== sourceModule) {
+                if (!edgeMap.has(sourceModule))
+                    edgeMap.set(sourceModule, new Map());
+                const targets = edgeMap.get(sourceModule);
+                targets.set(targetModule, (targets.get(targetModule) ?? 0) + 1);
+            }
+        }
+    }
+    // Build edges and update module dependencies/dependents
+    const edges = [];
+    const moduleMap = new Map(modules.map((m) => [m.path, m]));
+    for (const [from, targets] of edgeMap) {
+        for (const [to, count] of targets) {
+            edges.push({ from, to, importCount: count });
+            moduleMap.get(from)?.dependencies.push(to);
+            moduleMap.get(to)?.dependents.push(from);
+        }
+    }
+    const cycles = detectCycles(modules, edges);
+    return {
+        modules,
+        edges,
+        externalDependencies: [...externalDeps].sort(),
+        cycles,
+    };
+}
+/**
+ * Detect cycles in the module graph using DFS.
+ */
+function detectCycles(modules, edges) {
+    const adjacency = new Map();
+    for (const edge of edges) {
+        if (!adjacency.has(edge.from))
+            adjacency.set(edge.from, []);
+        adjacency.get(edge.from).push(edge.to);
+    }
+    const cycles = [];
+    const visited = new Set();
+    const inStack = new Set();
+    const stack = [];
+    function dfs(node) {
+        visited.add(node);
+        inStack.add(node);
+        stack.push(node);
+        for (const neighbor of adjacency.get(node) ?? []) {
+            if (!visited.has(neighbor)) {
+                dfs(neighbor);
+            }
+            else if (inStack.has(neighbor)) {
+                // Found a cycle — extract it from the stack
+                const cycleStart = stack.indexOf(neighbor);
+                if (cycleStart >= 0) {
+                    cycles.push([...stack.slice(cycleStart), neighbor]);
+                }
+            }
+        }
+        stack.pop();
+        inStack.delete(node);
+    }
+    for (const mod of modules) {
+        if (!visited.has(mod.path)) {
+            dfs(mod.path);
+        }
+    }
+    return cycles;
+}
+//# sourceMappingURL=dependency-parser.js.map

package/dist/analysis/file-walker.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Walk filesystem, count files, detect module boundaries.
+ * A module boundary is a directory containing index.ts, index.js, or package.json.
+ */
+import type { FileInfo, ModuleInfo } from './types.js';
+export interface WalkOptions {
+    include?: string[];
+    exclude?: string[];
+}
+/**
+ * Walk the filesystem starting from rootDir, collecting file info.
+ */
+export declare function walkFiles(rootDir: string, options?: WalkOptions): Promise<FileInfo[]>;
+/**
+ * Detect module boundaries — directories that contain a module marker file.
+ */
+export declare function detectModules(rootDir: string, options?: WalkOptions): Promise<ModuleInfo[]>;
+//# sourceMappingURL=file-walker.d.ts.map

package/dist/analysis/file-walker.js

@@ -0,0 +1,158 @@
+/**
+ * Walk filesystem, count files, detect module boundaries.
+ * A module boundary is a directory containing index.ts, index.js, or package.json.
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative, extname, basename } from 'node:path';
+const CODE_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.py',
+    '.go',
+    '.rs',
+    '.java',
+    '.rb',
+    '.php',
+    '.c',
+    '.cpp',
+    '.h',
+    '.hpp',
+    '.cs',
+    '.swift',
+]);
+const MODULE_MARKERS = ['index.ts', 'index.js', 'index.mjs', 'package.json'];
+function matchesGlob(filePath, patterns) {
+    for (const pattern of patterns) {
+        // Simple glob matching: supports ** and *
+        const regex = pattern
+            .replace(/\./g, '\\.')
+            .replace(/\*\*/g, '{{GLOBSTAR}}')
+            .replace(/\*/g, '[^/]*')
+            .replace(/\{\{GLOBSTAR\}\}/g, '.*');
+        if (new RegExp(`^${regex}$`).test(filePath) ||
+            new RegExp(`^${regex}$`).test(basename(filePath))) {
+            return true;
+        }
+    }
+    return false;
+}
+function shouldExclude(relativePath, exclude) {
+    if (exclude.length === 0)
+        return false;
+    return matchesGlob(relativePath, exclude);
+}
+async function countLines(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        return content.split('\n').length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Walk the filesystem starting from rootDir, collecting file info.
+ */
+export async function walkFiles(rootDir, options) {
+    const exclude = options?.exclude ?? [
+        'node_modules/**',
+        '.git/**',
+        'dist/**',
+        'build/**',
+        'coverage/**',
+    ];
+    const files = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            const relPath = relative(rootDir, fullPath);
+            if (shouldExclude(relPath, exclude))
+                continue;
+            if (entry.isDirectory()) {
+                // Also check directory-level exclusions
+                if (shouldExclude(relPath + '/', exclude))
+                    continue;
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                const ext = extname(entry.name);
+                if (CODE_EXTENSIONS.has(ext)) {
+                    const lineCount = await countLines(fullPath);
+                    files.push({
+                        path: fullPath,
+                        relativePath: relPath,
+                        lineCount,
+                        extension: ext,
+                    });
+                }
+            }
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+/**
+ * Detect module boundaries — directories that contain a module marker file.
+ */
+export async function detectModules(rootDir, options) {
+    const exclude = options?.exclude ?? [
+        'node_modules/**',
+        '.git/**',
+        'dist/**',
+        'build/**',
+        'coverage/**',
+    ];
+    const modules = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const relDir = relative(rootDir, dir);
+        if (relDir && shouldExclude(relDir + '/', exclude))
+            return;
+        const names = entries.map((e) => e.name);
+        const hasMarker = MODULE_MARKERS.some((m) => names.includes(m));
+        if (hasMarker && relDir) {
+            // Count files in this module
+            let fileCount = 0;
+            for (const entry of entries) {
+                if (entry.isFile() && CODE_EXTENSIONS.has(extname(entry.name))) {
+                    fileCount++;
+                }
+            }
+            modules.push({
+                name: relDir.split('/').pop() || relDir,
+                path: relDir,
+                fileCount,
+                dependencies: [],
+                dependents: [],
+            });
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const childRel = relative(rootDir, join(dir, entry.name));
+                if (!shouldExclude(childRel + '/', exclude)) {
+                    await walk(join(dir, entry.name));
+                }
+            }
+        }
+    }
+    await walk(rootDir);
+    return modules;
+}
+//# sourceMappingURL=file-walker.js.map

package/dist/analysis/hotspot-analyzer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Git log churn analysis + file complexity heuristic → composite hotspot score.
+ * Complexity heuristic: lineCount * 0.6 + importCount * 0.4, normalized to 1-10.
+ */
+import type { FileInfo, Hotspot, ImportStatement } from './types.js';
+interface ChurnEntry {
+    filePath: string;
+    commitCount: number;
+    lastModified?: string;
+}
+/**
+ * Run `git log` to get file churn data.
+ */
+export declare function getFileChurn(repoPath: string, historyDays?: number): Promise<ChurnEntry[]>;
+/**
+ * Compute file complexity as a heuristic: lineCount * 0.6 + importCount * 0.4.
+ * Normalized to 1-10 scale.
+ */
+export declare function computeFileComplexity(lineCount: number, importCount: number): number;
+/**
+ * Analyze hotspots: files with high churn and/or high complexity.
+ */
+export declare function analyzeHotspots(repoPath: string, files: FileInfo[], importsByFile: Map<string, ImportStatement[]>, options?: {
+    historyDays?: number;
+    threshold?: number;
+}): Promise<Hotspot[]>;
+export {};
+//# sourceMappingURL=hotspot-analyzer.d.ts.map

package/dist/analysis/hotspot-analyzer.js

@@ -0,0 +1,85 @@
+/**
+ * Git log churn analysis + file complexity heuristic → composite hotspot score.
+ * Complexity heuristic: lineCount * 0.6 + importCount * 0.4, normalized to 1-10.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { DEFAULT_GIT_HISTORY_DAYS, DEFAULT_HOTSPOT_THRESHOLD } from '../defaults.js';
+const execFileAsync = promisify(execFile);
+/**
+ * Run `git log` to get file churn data.
+ */
+export async function getFileChurn(repoPath, historyDays = DEFAULT_GIT_HISTORY_DAYS) {
+    try {
+        const since = `${historyDays} days ago`;
+        const { stdout } = await execFileAsync('git', ['log', '--format=', '--name-only', `--since=${since}`], { cwd: repoPath, maxBuffer: 10 * 1024 * 1024 });
+        const counts = new Map();
+        for (const line of stdout.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            counts.set(trimmed, (counts.get(trimmed) ?? 0) + 1);
+        }
+        // Get last modified dates
+        const entries = [];
+        for (const [filePath, commitCount] of counts) {
+            entries.push({ filePath, commitCount });
+        }
+        return entries;
+    }
+    catch {
+        // Not a git repo or git not available
+        return [];
+    }
+}
+/**
+ * Compute file complexity as a heuristic: lineCount * 0.6 + importCount * 0.4.
+ * Normalized to 1-10 scale.
+ */
+export function computeFileComplexity(lineCount, importCount) {
+    // Raw score: weighted sum
+    const raw = lineCount * 0.6 + importCount * 0.4;
+    // Normalize to 1-10 using a logarithmic scale
+    // ~50 lines + 5 imports ≈ 3, ~200 lines + 20 imports ≈ 5, ~500+ lines + 30+ imports ≈ 8+
+    const normalized = (Math.log2(raw + 1) / Math.log2(500)) * 10;
+    return Math.max(1, Math.min(10, Math.round(normalized)));
+}
+/**
+ * Analyze hotspots: files with high churn and/or high complexity.
+ */
+export async function analyzeHotspots(repoPath, files, importsByFile, options) {
+    const historyDays = options?.historyDays ?? DEFAULT_GIT_HISTORY_DAYS;
+    const threshold = options?.threshold ?? DEFAULT_HOTSPOT_THRESHOLD;
+    const churnEntries = await getFileChurn(repoPath, historyDays);
+    const churnMap = new Map(churnEntries.map((e) => [e.filePath, e]));
+    // Total commits to compute churn rate
+    const totalCommits = churnEntries.reduce((sum, e) => sum + e.commitCount, 0);
+    const hotspots = [];
+    for (const file of files) {
+        const churn = churnMap.get(file.relativePath);
+        const commitCount = churn?.commitCount ?? 0;
+        const churnRate = totalCommits > 0 ? commitCount / totalCommits : 0;
+        const imports = importsByFile.get(file.relativePath) ?? [];
+        const complexity = computeFileComplexity(file.lineCount, imports.length);
+        // Composite score: churnRate * 0.5 + normalizedComplexity * 0.5
+        const normalizedComplexity = complexity / 10;
+        const compositeScore = churnRate * 0.5 + normalizedComplexity * 0.5;
+        if (compositeScore >= threshold || complexity >= 7) {
+            hotspots.push({
+                filePath: file.relativePath,
+                churnRate: Math.round(churnRate * 1000) / 1000,
+                complexity,
+                commitCount,
+                lastModified: churn?.lastModified,
+            });
+        }
+    }
+    // Sort by composite score descending
+    hotspots.sort((a, b) => {
+        const scoreA = a.churnRate * 0.5 + (a.complexity / 10) * 0.5;
+        const scoreB = b.churnRate * 0.5 + (b.complexity / 10) * 0.5;
+        return scoreB - scoreA;
+    });
+    return hotspots;
+}
+//# sourceMappingURL=hotspot-analyzer.js.map

package/dist/analysis/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Barrel exports for the analysis module.
+ */
+export type { CodebaseProfile, CodebaseContext, Hotspot, ArchitecturalPattern, DetectedConvention, ModuleInfo, ModuleGraph, DependencyEdge, AnalyzerOptions, FileInfo, ImportStatement, } from './types.js';
+export { walkFiles, detectModules } from './file-walker.js';
+export { parseImports, buildModuleGraph } from './dependency-parser.js';
+export { detectConventions } from './convention-detector.js';
+export { detectPatterns } from './pattern-detector.js';
+export { analyzeHotspots } from './hotspot-analyzer.js';
+export { computeComplexityScore } from './complexity-scorer.js';
+export { analyzeCodebase } from './analyzer.js';
+export { buildCodebaseContext, formatContextForPrompt } from './context-builder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/analysis/index.js

@@ -0,0 +1,12 @@
+/**
+ * Barrel exports for the analysis module.
+ */
+export { walkFiles, detectModules } from './file-walker.js';
+export { parseImports, buildModuleGraph } from './dependency-parser.js';
+export { detectConventions } from './convention-detector.js';
+export { detectPatterns } from './pattern-detector.js';
+export { analyzeHotspots } from './hotspot-analyzer.js';
+export { computeComplexityScore } from './complexity-scorer.js';
+export { analyzeCodebase } from './analyzer.js';
+export { buildCodebaseContext, formatContextForPrompt } from './context-builder.js';
+//# sourceMappingURL=index.js.map