openlore 2.0.0

package/dist/core/services/mcp-handlers/analysis.js

@@ -0,0 +1,1185 @@
+/**
+ * MCP tool handlers for codebase analysis:
+ * analyze_codebase, get_architecture_overview, get_refactor_report,
+ * get_duplicate_report, get_signatures, get_mapping, check_spec_drift,
+ * get_function_skeleton, get_god_functions, get_route_inventory,
+ * get_middleware_inventory, get_schema_inventory, get_ui_components.
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { DEFAULT_MAX_FILES, DEFAULT_DRIFT_MAX_FILES, TOP_REFACTOR_ISSUES_LIMIT, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, OPENLORE_ANALYSIS_REL_PATH, OPENSPEC_DIR, ARTIFACT_DEPENDENCY_GRAPH, ARTIFACT_MAPPING, ARTIFACT_REPO_STRUCTURE, ARTIFACT_ROUTE_INVENTORY, ARTIFACT_MIDDLEWARE_INVENTORY, ARTIFACT_SCHEMA_INVENTORY, ARTIFACT_UI_INVENTORY, ARTIFACT_ENV_INVENTORY, ARTIFACT_EXTERNAL_PACKAGES, TRANSITIVE_SCORE_MAX, } from '../../../constants.js';
+import { runAnalysis } from '../../../cli/commands/analyze.js';
+import { analyzeForRefactoring } from '../../analyzer/refactor-analyzer.js';
+import { formatSignatureMaps } from '../../analyzer/signature-extractor.js';
+import { getSkeletonContent, detectLanguage, isSkeletonWorthIncluding } from '../../analyzer/code-shaper.js';
+import { buildArchitectureOverview } from '../../analyzer/architecture-writer.js';
+import { isGitRepository, getChangedFiles, buildSpecMap, buildADRMap, detectDrift, } from '../../drift/index.js';
+import { readOpenLoreConfig } from '../config-manager.js';
+import { validateDirectory, readCachedContext, isCacheFresh, safeJoin } from './utils.js';
+import { openloreAudit } from '../../../api/audit.js';
+// ============================================================================
+// HANDLERS
+// ============================================================================
+/**
+ * Run a full static analysis pass on `directory` and return a compact summary.
+ */
+export async function handleAnalyzeCodebase(directory, force) {
+    const absDir = await validateDirectory(directory);
+    const outputPath = join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR);
+    if (!force && await isCacheFresh(absDir)) {
+        const ctx = await readCachedContext(absDir);
+        if (ctx) {
+            const cg = ctx.callGraph;
+            const topRefactorIssues = cg
+                ? analyzeForRefactoring(cg).priorities.slice(0, TOP_REFACTOR_ISSUES_LIMIT).map(e => ({
+                    function: e.function, file: e.file, issues: e.issues, priorityScore: e.priorityScore,
+                }))
+                : [];
+            return {
+                cached: true,
+                callGraph: cg
+                    ? { totalNodes: cg.stats.totalNodes, totalEdges: cg.stats.totalEdges,
+                        hubs: cg.hubFunctions.length, entryPoints: cg.entryPoints.length,
+                        layerViolations: cg.layerViolations.length }
+                    : null,
+                topRefactorIssues,
+                analysisPath: OPENLORE_ANALYSIS_REL_PATH,
+            };
+        }
+    }
+    const result = await runAnalysis(absDir, outputPath, {
+        maxFiles: DEFAULT_MAX_FILES,
+        include: [],
+        exclude: [],
+    });
+    const { artifacts, repoMap, depGraph } = result;
+    const rs = artifacts.repoStructure;
+    const cg = artifacts.llmContext.callGraph;
+    let topRefactorIssues = [];
+    if (cg) {
+        const report = analyzeForRefactoring(cg);
+        topRefactorIssues = report.priorities.slice(0, TOP_REFACTOR_ISSUES_LIMIT).map(e => ({
+            function: e.function,
+            file: e.file,
+            issues: e.issues,
+            priorityScore: e.priorityScore,
+        }));
+    }
+    return {
+        projectName: rs.projectName,
+        projectType: rs.projectType,
+        frameworks: rs.frameworks,
+        architecture: rs.architecture.pattern,
+        stats: {
+            files: repoMap.summary.totalFiles,
+            analyzedFiles: repoMap.summary.analyzedFiles,
+            depNodes: depGraph.statistics.nodeCount,
+            depEdges: depGraph.statistics.edgeCount,
+            importEdges: depGraph.statistics.importEdgeCount,
+            httpCrossEdges: depGraph.statistics.httpEdgeCount,
+            cycles: depGraph.statistics.cycleCount,
+        },
+        callGraph: cg
+            ? {
+                totalNodes: cg.stats.totalNodes,
+                totalEdges: cg.stats.totalEdges,
+                hubs: cg.hubFunctions.length,
+                entryPoints: cg.entryPoints.length,
+                layerViolations: cg.layerViolations.length,
+            }
+            : null,
+        domains: rs.domains.map((d) => d.name),
+        topRefactorIssues,
+        analysisPath: OPENLORE_ANALYSIS_REL_PATH,
+    };
+}
+/**
+ * High-level architecture map: clusters, cross-cluster deps, entry points, hubs.
+ */
+export async function handleGetArchitectureOverview(directory) {
+    const absDir = await validateDirectory(directory);
+    let depGraph = null;
+    try {
+        const raw = await readFile(join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, ARTIFACT_DEPENDENCY_GRAPH), 'utf-8');
+        depGraph = JSON.parse(raw);
+    }
+    catch { /* ignore */ }
+    const ctx = await readCachedContext(absDir);
+    if (!depGraph && !ctx) {
+        return { error: 'No analysis found. Run analyze_codebase first.' };
+    }
+    const overview = buildArchitectureOverview(depGraph, ctx, absDir);
+    return {
+        summary: overview.summary,
+        clusters: overview.clusters,
+        globalEntryPoints: overview.globalEntryPoints,
+        criticalHubs: overview.criticalHubs,
+    };
+}
+/**
+ * Return a prioritized refactor report from cached analysis.
+ */
+export async function handleGetRefactorReport(directory) {
+    const absDir = await validateDirectory(directory);
+    const ctx = await readCachedContext(absDir);
+    if (!ctx)
+        return { error: 'No analysis found. Run analyze_codebase first.' };
+    if (!ctx.callGraph)
+        return { error: 'Call graph not available in cached analysis. Re-run analyze_codebase.' };
+    return analyzeForRefactoring(ctx.callGraph);
+}
+/**
+ * Read the cached duplicate detection result.
+ */
+export async function handleGetDuplicateReport(directory) {
+    const absDir = await validateDirectory(directory);
+    const cachePath = join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, 'duplicates.json');
+    let raw;
+    try {
+        raw = await readFile(cachePath, 'utf-8');
+    }
+    catch {
+        return {
+            error: 'No duplicate report found. Run analyze_codebase first ' +
+                '(duplicates.json is generated during analysis).',
+        };
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return { error: 'Duplicate report cache is corrupted. Re-run analyze_codebase.' };
+    }
+}
+/**
+ * Return compact function and class signatures for files in the project.
+ */
+export async function handleGetSignatures(directory, filePattern) {
+    const absDir = await validateDirectory(directory);
+    const ctx = await readCachedContext(absDir);
+    if (!ctx)
+        return 'No analysis found. Run analyze_codebase first.';
+    if (!ctx.signatures || ctx.signatures.length === 0) {
+        return 'No signatures available in cached analysis. Re-run analyze_codebase.';
+    }
+    const filtered = filePattern
+        ? ctx.signatures.filter((s) => s.path.includes(filePattern))
+        : ctx.signatures;
+    if (filtered.length === 0) {
+        return `No files matching pattern "${filePattern}" found in analysis.`;
+    }
+    const chunks = formatSignatureMaps(filtered);
+    return chunks.join('\n\n---\n\n');
+}
+/**
+ * Return the requirement→function mapping from mapping.json.
+ */
+export async function handleGetMapping(directory, domain, orphansOnly) {
+    const absDir = await validateDirectory(directory);
+    let raw;
+    try {
+        raw = await readFile(join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, ARTIFACT_MAPPING), 'utf-8');
+    }
+    catch {
+        return { error: 'No mapping found. Run openlore generate first.' };
+    }
+    let mapping;
+    try {
+        mapping = JSON.parse(raw);
+    }
+    catch {
+        return { error: 'Mapping file is corrupted. Re-run openlore generate.' };
+    }
+    if (orphansOnly) {
+        const filtered = domain
+            ? mapping.orphanFunctions.filter((f) => f.file.includes(domain))
+            : mapping.orphanFunctions;
+        return { generatedAt: mapping.generatedAt, stats: mapping.stats, orphanFunctions: filtered };
+    }
+    const filteredMappings = domain
+        ? mapping.mappings.filter((m) => m.domain === domain)
+        : mapping.mappings;
+    return {
+        generatedAt: mapping.generatedAt,
+        stats: mapping.stats,
+        mappings: filteredMappings,
+        orphanFunctions: domain ? [] : mapping.orphanFunctions,
+    };
+}
+/**
+ * Run spec-drift detection in static mode (no LLM).
+ */
+export async function handleCheckSpecDrift(directory, base = 'auto', files = [], domains = [], failOn = 'warning', maxFiles = DEFAULT_DRIFT_MAX_FILES) {
+    const absDir = await validateDirectory(directory);
+    if (!(await isGitRepository(absDir))) {
+        return { error: 'Not a git repository. Drift detection requires git.' };
+    }
+    const openloreConfig = await readOpenLoreConfig(absDir);
+    if (!openloreConfig) {
+        return { error: 'No openlore configuration found. Run "openlore init" first.' };
+    }
+    const openspecPath = join(absDir, openloreConfig.openspecPath ?? OPENSPEC_DIR);
+    const specsPath = join(openspecPath, 'specs');
+    try {
+        await stat(specsPath);
+    }
+    catch {
+        return { error: 'No specs found. Run "openlore generate" first.' };
+    }
+    const startTime = Date.now();
+    const gitResult = await getChangedFiles({
+        rootPath: absDir,
+        baseRef: base,
+        pathFilter: files.length > 0 ? files : undefined,
+        includeUnstaged: true,
+    });
+    if (gitResult.files.length === 0) {
+        return {
+            timestamp: new Date().toISOString(),
+            baseRef: gitResult.resolvedBase,
+            totalChangedFiles: 0,
+            specRelevantFiles: 0,
+            issues: [],
+            summary: { gaps: 0, stale: 0, uncovered: 0, orphanedSpecs: 0, adrGaps: 0, adrOrphaned: 0, total: 0 },
+            hasDrift: false,
+            duration: Date.now() - startTime,
+            mode: 'static',
+        };
+    }
+    const actualChangedFiles = gitResult.files.length;
+    if (gitResult.files.length > maxFiles) {
+        gitResult.files = gitResult.files.slice(0, maxFiles);
+    }
+    const repoStructurePath = join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, ARTIFACT_REPO_STRUCTURE);
+    let hasRepoStructure = false;
+    try {
+        await stat(repoStructurePath);
+        hasRepoStructure = true;
+    }
+    catch { /* no prior analysis */ }
+    const specMap = await buildSpecMap({
+        rootPath: absDir,
+        openspecPath,
+        repoStructurePath: hasRepoStructure ? repoStructurePath : undefined,
+    });
+    const adrMap = await buildADRMap({
+        rootPath: absDir,
+        openspecPath,
+        repoStructurePath: hasRepoStructure ? repoStructurePath : undefined,
+    });
+    const result = await detectDrift({
+        rootPath: absDir,
+        specMap,
+        changedFiles: gitResult.files,
+        failOn,
+        domainFilter: domains.length > 0 ? domains : undefined,
+        openspecRelPath: openloreConfig.openspecPath ?? OPENSPEC_DIR,
+        baseRef: gitResult.resolvedBase,
+        adrMap: adrMap ?? undefined,
+    });
+    result.baseRef = gitResult.resolvedBase;
+    result.totalChangedFiles = actualChangedFiles;
+    return result;
+}
+/**
+ * Return a noise-stripped skeleton of a source file.
+ */
+export async function handleGetFunctionSkeleton(directory, filePath) {
+    const absDir = await validateDirectory(directory);
+    const absFile = safeJoin(absDir, filePath);
+    let source;
+    try {
+        source = await readFile(absFile, 'utf-8');
+    }
+    catch {
+        return { error: `File not found: ${filePath}` };
+    }
+    const language = detectLanguage(filePath);
+    const skeleton = getSkeletonContent(source, language);
+    const worthIncluding = isSkeletonWorthIncluding(source, skeleton);
+    return {
+        filePath,
+        language,
+        originalLines: source.split('\n').length,
+        skeletonLines: skeleton.split('\n').length,
+        reductionPct: Math.round((1 - skeleton.length / source.length) * 100),
+        worthIncluding,
+        skeleton,
+    };
+}
+// Note: handleGetGodFunctions lives in graph.ts (alongside other call-graph tools)
+/**
+ * Extract the exact source text of a named function using the cached call graph.
+ *
+ * Uses the startIndex/endIndex byte offsets recorded in llm-context.json to
+ * slice the source file — no extra tree-sitter parsing needed at query time.
+ * Falls back to a line-number scan when the call graph is unavailable.
+ */
+export async function handleGetFunctionBody(directory, filePath, functionName) {
+    const absDir = await validateDirectory(directory);
+    const absFile = safeJoin(absDir, filePath);
+    let source;
+    try {
+        source = await readFile(absFile, 'utf-8');
+    }
+    catch {
+        return { error: `File not found: ${filePath}` };
+    }
+    // Try call graph first: exact byte-range slice, no ambiguity
+    const contextPath = join(absDir, '.openlore', 'analysis', 'llm-context.json');
+    try {
+        const raw = await readFile(contextPath, 'utf-8');
+        const ctx = JSON.parse(raw);
+        if (ctx.callGraph?.nodes) {
+            const node = ctx.callGraph.nodes.find(n => n.name === functionName && (n.filePath === filePath || n.filePath.endsWith('/' + filePath.replace(/^\//, ''))));
+            if (node && node.startIndex < node.endIndex) {
+                const body = source.slice(node.startIndex, node.endIndex);
+                return {
+                    functionName,
+                    filePath,
+                    language: node.language,
+                    className: node.className ?? null,
+                    startIndex: node.startIndex,
+                    endIndex: node.endIndex,
+                    body,
+                    lineCount: body.split('\n').length,
+                };
+            }
+        }
+    }
+    catch { /* no call graph — fall through to line-scan */ }
+    // Fallback: find the function by scanning for its declaration line
+    const lines = source.split('\n');
+    const declPattern = new RegExp(`\\b${functionName}\\s*[(<]`);
+    const startLine = lines.findIndex(l => declPattern.test(l));
+    if (startLine === -1) {
+        return { error: `Function "${functionName}" not found in ${filePath}. Run analyze_codebase first for exact byte-range extraction.` };
+    }
+    // Collect lines until matching brace depth returns to 0 (works for C-style languages)
+    let depth = 0;
+    let endLine = startLine;
+    for (let i = startLine; i < lines.length; i++) {
+        for (const ch of lines[i]) {
+            if (ch === '{')
+                depth++;
+            else if (ch === '}')
+                depth--;
+        }
+        if (depth > 0 || i === startLine) {
+            endLine = i;
+            continue;
+        }
+        endLine = i;
+        break;
+    }
+    const body = lines.slice(startLine, endLine + 1).join('\n');
+    return {
+        functionName,
+        filePath,
+        language: detectLanguage(filePath),
+        className: null,
+        startLine: startLine + 1,
+        endLine: endLine + 1,
+        body,
+        lineCount: endLine - startLine + 1,
+        note: 'Extracted via line scan (no call graph available). Run analyze_codebase for exact extraction.',
+    };
+}
+/**
+ * List and optionally filter Architecture Decision Records from openspec/decisions/.
+ */
+export async function handleGetDecisions(directory, query) {
+    const { existsSync } = await import('node:fs');
+    const { readdir } = await import('node:fs/promises');
+    const { join: pjoin } = await import('node:path');
+    const absDir = await validateDirectory(directory);
+    // Resolve openspec path from config if present
+    let openspecRelPath = 'openspec';
+    try {
+        const cfgRaw = await readFile(join(absDir, '.openlore', 'config.json'), 'utf-8');
+        const cfg = JSON.parse(cfgRaw);
+        if (cfg.openspecPath)
+            openspecRelPath = cfg.openspecPath;
+    }
+    catch { /* use default */ }
+    const decisionsDir = pjoin(absDir, openspecRelPath, 'decisions');
+    if (!existsSync(decisionsDir)) {
+        return { decisions: [], note: `No decisions directory found at ${openspecRelPath}/decisions/. Run "openlore generate --adrs" first.` };
+    }
+    let entries;
+    try {
+        entries = await readdir(decisionsDir);
+    }
+    catch {
+        return { decisions: [] };
+    }
+    // Each ADR is a .md file directly in decisions/
+    const adrFiles = entries.filter(e => e.endsWith('.md'));
+    // Read all ADR files in parallel
+    const adrs = await Promise.all(adrFiles.map(async (filename) => {
+        const filePath = pjoin(decisionsDir, filename);
+        const content = await readFile(filePath, 'utf-8');
+        // Extract title from first H1 or H2
+        const titleMatch = content.match(/^#{1,2}\s+(.+)$/m);
+        const title = titleMatch?.[1]?.trim() ?? filename.replace(/\.md$/, '');
+        // Extract status from "Status:" line (ADR convention)
+        const statusMatch = content.match(/^\*\*?Status\*\*?:?\s*(.+)$/im);
+        const status = statusMatch?.[1]?.trim() ?? 'unknown';
+        return { filename, title, status, content };
+    }));
+    // Filter by query text if provided
+    const lowerQuery = query?.toLowerCase();
+    const filtered = lowerQuery
+        ? adrs.filter(a => a.title.toLowerCase().includes(lowerQuery) ||
+            a.content.toLowerCase().includes(lowerQuery))
+        : adrs;
+    return {
+        count: filtered.length,
+        query: query ?? null,
+        decisions: filtered.map(a => ({
+            filename: a.filename,
+            title: a.title,
+            status: a.status,
+            content: a.content,
+        })),
+    };
+}
+// ============================================================================
+// ROUTE INVENTORY HANDLER
+// ============================================================================
+/**
+ * Return the pre-computed route inventory from the last analysis run.
+ * Falls back to re-computing from source files if the artifact is missing.
+ */
+export async function handleGetRouteInventory(directory) {
+    const absDir = await validateDirectory(directory);
+    const artifactPath = join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, ARTIFACT_ROUTE_INVENTORY);
+    // Try reading cached artifact first
+    try {
+        const raw = await readFile(artifactPath, 'utf-8');
+        const inventory = JSON.parse(raw);
+        return { cached: true, ...inventory };
+    }
+    catch {
+        // Artifact not present — run live extraction
+    }
+    const { buildRouteInventory } = await import('../../analyzer/http-route-parser.js');
+    const { RepositoryMapper } = await import('../../analyzer/repository-mapper.js');
+    const { readOpenLoreConfig } = await import('../config-manager.js');
+    const openloreConfig = await readOpenLoreConfig(absDir);
+    const configExclude = openloreConfig?.analysis.excludePatterns ?? [];
+    const mapper = new RepositoryMapper(absDir, {
+        maxFiles: DEFAULT_MAX_FILES,
+        excludePatterns: configExclude.length > 0 ? configExclude : undefined,
+    });
+    const repoMap = await mapper.map();
+    const filePaths = repoMap.allFiles.map(f => f.path);
+    const inventory = await buildRouteInventory(filePaths, absDir);
+    return { cached: false, ...inventory };
+}
+// ============================================================================
+// MIDDLEWARE INVENTORY HANDLER
+// ============================================================================
+/**
+ * Return the pre-computed middleware inventory from the last analysis run.
+ * Falls back to re-computing from source files if the artifact is missing.
+ */
+export async function handleGetMiddlewareInventory(directory) {
+    const absDir = await validateDirectory(directory);
+    const artifactPath = join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, ARTIFACT_MIDDLEWARE_INVENTORY);
+    // Try reading cached artifact first
+    try {
+        const raw = await readFile(artifactPath, 'utf-8');
+        const inventory = JSON.parse(raw);
+        return { cached: true, total: inventory.length, entries: inventory };
+    }
+    catch {
+        // Artifact not present — run live extraction
+    }
+    const { extractMiddleware } = await import('../../analyzer/middleware-extractor.js');
+    const { RepositoryMapper } = await import('../../analyzer/repository-mapper.js');
+    const { readOpenLoreConfig } = await import('../config-manager.js');
+    const openloreConfig = await readOpenLoreConfig(absDir);
+    const configExclude = openloreConfig?.analysis.excludePatterns ?? [];
+    const mapper = new RepositoryMapper(absDir, {
+        maxFiles: DEFAULT_MAX_FILES,
+        excludePatterns: configExclude.length > 0 ? configExclude : undefined,
+    });
+    const repoMap = await mapper.map();
+    const filePaths = repoMap.allFiles.map(f => f.path);
+    const entries = await extractMiddleware(filePaths, absDir);
+    return { cached: false, total: entries.length, entries };
+}
+// ============================================================================
+// SCHEMA INVENTORY HANDLER
+// ============================================================================
+/**
+ * Return the pre-computed database schema inventory from the last analysis run.
+ * Falls back to re-computing from source files if the artifact is missing.
+ */
+export async function handleGetSchemaInventory(directory) {
+    const absDir = await validateDirectory(directory);
+    const artifactPath = join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, ARTIFACT_SCHEMA_INVENTORY);
+    try {
+        const raw = await readFile(artifactPath, 'utf-8');
+        const schemas = JSON.parse(raw);
+        return { cached: true, total: schemas.length, schemas };
+    }
+    catch {
+        // Artifact not present — run live extraction
+    }
+    const { extractSchemas } = await import('../../analyzer/schema-extractor.js');
+    const { RepositoryMapper } = await import('../../analyzer/repository-mapper.js');
+    const { readOpenLoreConfig } = await import('../config-manager.js');
+    const openloreConfig = await readOpenLoreConfig(absDir);
+    const configExclude = openloreConfig?.analysis.excludePatterns ?? [];
+    const mapper = new RepositoryMapper(absDir, {
+        maxFiles: DEFAULT_MAX_FILES,
+        excludePatterns: configExclude.length > 0 ? configExclude : undefined,
+    });
+    const repoMap = await mapper.map();
+    const filePaths = repoMap.allFiles.map(f => f.path);
+    const schemas = await extractSchemas(filePaths, absDir);
+    return { cached: false, total: schemas.length, schemas };
+}
+// ============================================================================
+// UI COMPONENTS HANDLER
+// ============================================================================
+/**
+ * Return the pre-computed UI component inventory from the last analysis run.
+ * Falls back to re-computing from source files if the artifact is missing.
+ */
+export async function handleGetUIComponents(directory) {
+    const absDir = await validateDirectory(directory);
+    const artifactPath = join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, ARTIFACT_UI_INVENTORY);
+    try {
+        const raw = await readFile(artifactPath, 'utf-8');
+        const components = JSON.parse(raw);
+        return { cached: true, total: components.length, components };
+    }
+    catch {
+        // Artifact not present — run live extraction
+    }
+    const { extractUIComponents } = await import('../../analyzer/ui-component-extractor.js');
+    const { RepositoryMapper } = await import('../../analyzer/repository-mapper.js');
+    const { readOpenLoreConfig } = await import('../config-manager.js');
+    const openloreConfig = await readOpenLoreConfig(absDir);
+    const configExclude = openloreConfig?.analysis.excludePatterns ?? [];
+    const mapper = new RepositoryMapper(absDir, {
+        maxFiles: DEFAULT_MAX_FILES,
+        excludePatterns: configExclude.length > 0 ? configExclude : undefined,
+    });
+    const repoMap = await mapper.map();
+    const filePaths = repoMap.allFiles.map(f => f.path);
+    const components = await extractUIComponents(filePaths, absDir);
+    return { cached: false, total: components.length, components };
+}
+// ============================================================================
+// ENV VARS HANDLER
+// ============================================================================
+/**
+ * Return the pre-computed environment variable inventory from the last analysis run.
+ * Falls back to re-computing from source files if the artifact is missing.
+ */
+export async function handleGetEnvVars(directory) {
+    const absDir = await validateDirectory(directory);
+    const artifactPath = join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, ARTIFACT_ENV_INVENTORY);
+    try {
+        const raw = await readFile(artifactPath, 'utf-8');
+        const envVars = JSON.parse(raw);
+        return { cached: true, total: envVars.length, envVars };
+    }
+    catch {
+        // Artifact not present — run live extraction
+    }
+    const { extractEnvVars } = await import('../../analyzer/env-extractor.js');
+    const { RepositoryMapper } = await import('../../analyzer/repository-mapper.js');
+    const { readOpenLoreConfig } = await import('../config-manager.js');
+    const openloreConfig = await readOpenLoreConfig(absDir);
+    const configExclude = openloreConfig?.analysis.excludePatterns ?? [];
+    const mapper = new RepositoryMapper(absDir, {
+        maxFiles: DEFAULT_MAX_FILES,
+        excludePatterns: configExclude.length > 0 ? configExclude : undefined,
+    });
+    const repoMap = await mapper.map();
+    const filePaths = repoMap.allFiles.map(f => f.path);
+    const envVars = await extractEnvVars(filePaths, absDir);
+    return { cached: false, total: envVars.length, envVars };
+}
+// ============================================================================
+// EXTERNAL PACKAGES HANDLER
+// ============================================================================
+/**
+ * Return direct external dependencies from package manifests
+ * (package.json, pyproject.toml, requirements.txt, Cargo.toml, go.mod).
+ * Falls back to live extraction if cached artifact is absent.
+ */
+export async function handleGetExternalPackages(directory) {
+    const absDir = await validateDirectory(directory);
+    const artifactPath = join(absDir, OPENLORE_DIR, OPENLORE_ANALYSIS_SUBDIR, ARTIFACT_EXTERNAL_PACKAGES);
+    try {
+        const raw = await readFile(artifactPath, 'utf-8');
+        const result = JSON.parse(raw);
+        return { cached: true, ...result };
+    }
+    catch { /* not cached */ }
+    const { extractExternalPackages } = await import('../../analyzer/external-packages.js');
+    const result = await extractExternalPackages(absDir);
+    return { cached: false, ...result };
+}
+/**
+ * Parity audit: report spec coverage gaps without any LLM call.
+ * Returns uncovered functions, hub gaps, orphan requirements, and stale domains.
+ */
+export async function handleAuditSpecCoverage(directory, maxUncovered = 50, hubThreshold = 5) {
+    const absDir = await validateDirectory(directory);
+    try {
+        const report = await openloreAudit({
+            rootPath: absDir,
+            maxUncovered,
+            hubThreshold,
+            save: true,
+        });
+        return report;
+    }
+    catch (err) {
+        return { error: `Audit failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+// ============================================================================
+// TEST GENERATION HANDLERS
+// ============================================================================
+/**
+ * Generate spec-driven test files from OpenSpec scenarios.
+ */
+export async function handleGenerateTests(args) {
+    const absDir = await validateDirectory(args.directory);
+    const { parseScenarios, generateTests, writeTestFiles, detectFramework } = await import('../../../core/test-generator/index.js');
+    const { FRAMEWORK_EXTENSIONS } = await import('../../../types/test-generator.js');
+    const scenarios = await parseScenarios({
+        rootPath: absDir,
+        domains: args.domains,
+    });
+    if (scenarios.length === 0) {
+        return { files: [], message: 'No scenarios found. Run "openlore generate" first.' };
+    }
+    // Resolve framework
+    let framework;
+    const valid = Object.keys(FRAMEWORK_EXTENSIONS);
+    if (!args.framework || args.framework === 'auto') {
+        framework = await detectFramework(absDir);
+    }
+    else if (valid.includes(args.framework)) {
+        framework = args.framework;
+    }
+    else {
+        return { error: `Unknown framework "${args.framework}". Valid: ${valid.join(', ')}` };
+    }
+    const files = await generateTests({
+        scenarios,
+        framework,
+        outputDir: 'spec-tests',
+        rootPath: absDir,
+        useLlm: args.useLlm ?? false,
+    });
+    const dryRun = args.dryRun ?? true; // MCP defaults to dry-run for safety
+    const writeResult = await writeTestFiles({
+        files,
+        rootPath: absDir,
+        dryRun,
+        merge: false,
+    });
+    return {
+        framework,
+        dryRun,
+        files: files.map((f) => ({
+            path: f.outputPath,
+            domain: f.domain,
+            scenarioCount: f.scenarios.length,
+            content: f.content,
+        })),
+        summary: writeResult,
+    };
+}
+/**
+ * Report spec test coverage for a project.
+ */
+export async function handleGetTestCoverage(args) {
+    const absDir = await validateDirectory(args.directory);
+    const { analyzeTestCoverage } = await import('../../../core/test-generator/index.js');
+    const report = await analyzeTestCoverage({
+        rootPath: absDir,
+        testDirs: ['spec-tests', 'src'],
+        domains: args.domains,
+        minCoverage: args.minCoverage,
+        // discover without LLM: tag-based only
+        discover: false,
+    });
+    return report;
+}
+// ============================================================================
+// get_minimal_context
+// ============================================================================
+/**
+ * Return the bare minimum an agent needs to safely modify a function:
+ * its signature + body, direct callers (signatures), direct callees (signatures),
+ * and which test files cover it. Typically 200-600 tokens vs orient's 2000+.
+ */
+export async function handleGetMinimalContext(directory, functionName, filePath) {
+    const absDir = await validateDirectory(directory);
+    const ctx = await readCachedContext(absDir);
+    if (!ctx?.callGraph)
+        return { error: 'No call graph. Run analyze_codebase first.' };
+    const cg = ctx.callGraph;
+    const nodeMap = new Map(cg.nodes.map(n => [n.id, n]));
+    // Find target node(s)
+    const candidates = cg.nodes.filter(n => n.name === functionName &&
+        !n.isExternal && !n.isTest &&
+        (!filePath || n.filePath.endsWith(filePath)));
+    if (candidates.length === 0)
+        return { error: `Function "${functionName}" not found. Run analyze_codebase first.` };
+    const target = candidates[0];
+    // Risk-aware depth: high fan-in/out functions get more caller/callee context
+    const riskLevel = target.fanIn >= 30 || target.fanOut >= 15 ? 'high' :
+        target.fanIn >= 15 || target.fanOut >= 8 ? 'medium' : 'low';
+    const callerLimit = riskLevel === 'high' ? 24 : riskLevel === 'medium' ? 18 : 12;
+    const calleeLimit = riskLevel === 'high' ? 24 : riskLevel === 'medium' ? 18 : 12;
+    // Direct callers and callees from calls edges
+    const callsEdges = cg.edges.filter(e => !e.kind || e.kind === 'calls');
+    const sig = (n) => n.signature ?? n.name + (n.isExternal ? ' [external]' : '');
+    // Build per-callee edge list to get callType
+    const edgesForCallee = new Map();
+    const edgesForCaller = new Map();
+    for (const e of callsEdges) {
+        if (!edgesForCallee.has(e.calleeId))
+            edgesForCallee.set(e.calleeId, []);
+        edgesForCallee.get(e.calleeId).push({ callerId: e.callerId, callType: e.callType });
+        if (!edgesForCaller.has(e.callerId))
+            edgesForCaller.set(e.callerId, []);
+        edgesForCaller.get(e.callerId).push({ calleeId: e.calleeId, callType: e.callType });
+    }
+    const callerEdges = edgesForCallee.get(target.id) ?? [];
+    const calleeEdgeList = edgesForCaller.get(target.id) ?? [];
+    const callerIds = callerEdges.map(e => e.callerId);
+    const calleeIds = calleeEdgeList.map(e => e.calleeId);
+    const callers = [...new Set(callerIds)]
+        .map(id => {
+        const n = nodeMap.get(id);
+        if (!n || n.isExternal)
+            return null;
+        const edge = callerEdges.find(e => e.callerId === id);
+        return { name: n.name, file: relative(absDir, n.filePath), sig: sig(n), callType: edge?.callType ?? 'direct', isExternal: false };
+    })
+        .filter((n) => !!n)
+        .slice(0, callerLimit);
+    const callees = [...new Set(calleeIds)]
+        .map(id => {
+        const n = nodeMap.get(id);
+        if (!n)
+            return null;
+        const edge = calleeEdgeList.find(e => e.calleeId === id);
+        return {
+            name: n.isExternal ? `[external] ${n.name}` : n.name,
+            file: n.isExternal ? 'external' : relative(absDir, n.filePath),
+            sig: sig(n),
+            callType: edge?.callType ?? 'direct',
+            isExternal: n.isExternal ?? false,
+            kind: n.externalKind,
+        };
+    })
+        .filter((n) => !!n)
+        .slice(0, calleeLimit);
+    // Test coverage — distinguish import-based vs call-based tracing
+    const seenTestNames = new Set();
+    const testedBy = cg.edges
+        .filter(e => e.kind === 'tested_by' && e.callerId === target.id)
+        .flatMap(e => {
+        if (seenTestNames.has(e.calleeName))
+            return [];
+        seenTestNames.add(e.calleeName);
+        const confidence = e.confidence === 'import' ? 'imported' : 'called';
+        return [{ name: e.calleeName, confidence }];
+    });
+    // Function body (byte-range slice from source)
+    let body = null;
+    try {
+        const src = await readFile(target.filePath, 'utf-8');
+        body = src.slice(target.startIndex, target.endIndex);
+    }
+    catch { /* source unavailable */ }
+    return {
+        function: {
+            name: target.name,
+            file: relative(absDir, target.filePath),
+            signature: target.signature ?? target.name,
+            language: target.language,
+            className: target.className ?? null,
+            startLine: target.startLine ?? null,
+            fanIn: target.fanIn,
+            fanOut: target.fanOut,
+            community: target.communityLabel ?? null,
+            riskLevel,
+            body,
+        },
+        callers,
+        callees,
+        testedBy,
+    };
+}
+// ============================================================================
+// get_cluster
+// ============================================================================
+/**
+ * Return all functions in the same community as the given function.
+ * Communities are computed via label propagation on the call graph at analyze time.
+ * Useful for understanding the "cluster" of related functions without traversing the graph.
+ */
+export async function handleGetCluster(directory, functionName) {
+    const absDir = await validateDirectory(directory);
+    const ctx = await readCachedContext(absDir);
+    if (!ctx?.callGraph)
+        return { error: 'No call graph. Run analyze_codebase first.' };
+    const cg = ctx.callGraph;
+    // Find the target node
+    const target = cg.nodes.find(n => n.name === functionName && !n.isExternal && !n.isTest);
+    if (!target)
+        return { error: `Function "${functionName}" not found.` };
+    if (!target.communityId)
+        return { error: `No community data. Re-run analyze_codebase.` };
+    // All nodes in same community
+    const members = cg.nodes
+        .filter(n => n.communityId === target.communityId && !n.isExternal && !n.isTest)
+        .sort((a, b) => b.fanIn - a.fanIn);
+    // Internal edges within community
+    const memberIds = new Set(members.map(n => n.id));
+    const nameById = new Map(members.map(n => [n.id, n.name]));
+    const rawInternal = cg.edges
+        .filter(e => (!e.kind || e.kind === 'calls') && memberIds.has(e.callerId) && memberIds.has(e.calleeId));
+    // Deduplicate, count all unique internal edges for density, show top 15
+    const seen = new Set();
+    const callEdges = [];
+    let uniqueInternalCount = 0;
+    for (const e of rawInternal) {
+        const key = `${e.callerId}→${e.calleeId}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        uniqueInternalCount++;
+        if (callEdges.length < 15) {
+            callEdges.push(`${nameById.get(e.callerId)} → ${nameById.get(e.calleeId)}`);
+        }
+    }
+    const m = members.length;
+    const clusterDensity = m > 1 ? Math.round((uniqueInternalCount / (m * (m - 1))) * 1000) / 1000 : 0;
+    // Files the community spans
+    const files = [...new Set(members.map(n => relative(absDir, n.filePath)))].sort();
+    return {
+        communityLabel: target.communityLabel,
+        communityId: target.communityId,
+        stats: {
+            members: m,
+            files: files.length,
+            internalEdges: uniqueInternalCount,
+            clusterDensity,
+        },
+        files,
+        // Internal call edges show WHY these functions cluster together
+        internalCallGraph: callEdges,
+        functions: members.map(n => ({
+            name: n.name,
+            file: relative(absDir, n.filePath),
+            signature: n.signature ?? n.name,
+            fanIn: n.fanIn,
+            fanOut: n.fanOut,
+        })),
+    };
+}
+// ============================================================================
+// detect_changes
+// ============================================================================
+/** Run git with explicit stdio pipes — safe inside MCP server (which owns stdin/stdout). */
+function runGit(args, cwd) {
+    // Use shell file-redirect to temp files instead of pipes — libuv pipe() calls
+    // fail with EBADF inside the MCP server because its FD 0/1 are the JSON-RPC
+    // protocol sockets; avoiding pipe creation altogether sidesteps the issue.
+    return new Promise((resolve, reject) => {
+        const PATH = (process.env.PATH ?? '') + ':/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin';
+        const tmp = mkdtempSync(join(tmpdir(), 'sg-git-'));
+        const outPath = join(tmp, 'o');
+        const errPath = join(tmp, 'e');
+        const escaped = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+        const cmd = `/usr/bin/git ${escaped} >'${outPath}' 2>'${errPath}'`;
+        const r = spawnSync('/bin/sh', ['-c', cmd], {
+            cwd,
+            stdio: 'ignore',
+            env: { ...process.env, PATH },
+        });
+        let stdout = '';
+        let stderr = '';
+        try {
+            stdout = readFileSync(outPath, 'utf8');
+        }
+        catch { /* no output */ }
+        try {
+            stderr = readFileSync(errPath, 'utf8');
+        }
+        catch { /* no output */ }
+        rmSync(tmp, { recursive: true, force: true });
+        if (r.error) {
+            reject(r.error);
+            return;
+        }
+        if ((r.status ?? 1) !== 0) {
+            reject(new Error(stderr || `git exit ${r.status}`));
+            return;
+        }
+        resolve(stdout);
+    });
+}
+// ── change-type classifier ────────────────────────────────────────────────────
+// Signature line patterns across languages (TS/JS, Python, Go, Rust, Java/C++)
+const SIG_PATTERN = /^\s*(export\s+)?(default\s+)?(async\s+)?function\b|\bdef\s+\w+\s*[([:]|\bfunc\s+(\([^)]*\)\s*)?\w+\s*\(|\bfn\s+\w+\b|\bclass\s+\w+/;
+// Control-flow keywords (broad, multi-language)
+const LOGIC_PATTERN = /\b(if|else|for|while|switch|try|catch|throw|return|yield|await|break|continue|elif|except|raise|match|case)\b/;
+function classifyChangeType(node, addedLines) {
+    const fnStart = node.startLine ?? 1;
+    const fnEnd = node.endLine ?? fnStart;
+    const linesInFn = [];
+    for (const [ln, content] of addedLines) {
+        if (ln >= fnStart && ln <= fnEnd)
+            linesInFn.push(content);
+    }
+    if (linesInFn.length === 0)
+        return 'logic';
+    // Signature change: function's own declaration line was modified
+    const sigLine = addedLines.get(fnStart);
+    if (sigLine !== undefined && SIG_PATTERN.test(sigLine))
+        return 'signature';
+    // Logic change: any added line has a control-flow keyword
+    if (linesInFn.some(l => LOGIC_PATTERN.test(l)))
+        return 'logic';
+    return 'config';
+}
+const CHANGE_TYPE_MULTIPLIER = {
+    signature: 1.5, // breaking-change candidate
+    logic: 1.0, // default
+    config: 0.4, // literal / comment / config tweak
+};
+function buildReason(params) {
+    const { changeType, directCallers, tests, bScore, fanIn } = params;
+    const parts = [];
+    if (changeType === 'signature')
+        parts.push('signature change');
+    else if (changeType === 'config')
+        parts.push('config/literal change');
+    if (fanIn > 0) {
+        const awaitedCount = directCallers.filter(c => c.callType === 'awaited').length;
+        const total = directCallers.length || fanIn;
+        if (awaitedCount === total && awaitedCount > 0)
+            parts.push('all callers awaited');
+        else if (awaitedCount > 0)
+            parts.push(`${awaitedCount} awaited callers`);
+        else
+            parts.push(`${fanIn} callers`);
+    }
+    const calledTests = tests.filter(t => t.confidence === 'called').length;
+    if (tests.length === 0)
+        parts.push('no tests');
+    else if (calledTests === 0)
+        parts.push('import-only tests');
+    else
+        parts.push(`${calledTests} direct test${calledTests > 1 ? 's' : ''}`);
+    if (bScore >= 0.67)
+        parts.push('HTTP/DB boundary');
+    else if (bScore > 0)
+        parts.push('external boundary');
+    return parts.join(' · ') || 'low-risk change';
+}
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Detect recently changed functions and rank them by blast radius (fanIn of callers via BFS).
+ * Runs git diff to find changed files/lines, maps to function nodes, scores by impact.
+ */
+export async function handleDetectChanges(directory, base) {
+    const absDir = await validateDirectory(directory);
+    const ctx = await readCachedContext(absDir);
+    if (!ctx?.callGraph)
+        return { error: 'No call graph. Run analyze_codebase first.' };
+    const ref = base ?? 'HEAD';
+    let diffOutput;
+    try {
+        diffOutput = await runGit(['diff', '--unified=0', ref, '--', '.'], absDir);
+        if (!diffOutput.trim()) {
+            diffOutput = await runGit(['diff', '--unified=0', '--cached', '--', '.'], absDir);
+        }
+    }
+    catch (err) {
+        return { error: `git diff failed: ${err.message}` };
+    }
+    if (!diffOutput.trim())
+        return { changedFunctions: [], message: 'No changes detected.' };
+    // Parse unified diff: collect line ranges AND added-line content per file.
+    // --unified=0 means no context lines; only '+' and '-' lines appear in hunks.
+    const changedFileData = new Map();
+    let curFile = null;
+    let newLineNum = 0;
+    for (const line of diffOutput.split('\n')) {
+        const fileMatch = line.match(/^\+\+\+ b\/(.+)$/);
+        if (fileMatch) {
+            curFile = join(absDir, fileMatch[1]);
+            newLineNum = 0;
+            continue;
+        }
+        const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+        if (hunkMatch && curFile) {
+            newLineNum = parseInt(hunkMatch[1], 10);
+            const count = hunkMatch[2] !== undefined ? parseInt(hunkMatch[2], 10) : 1;
+            if (count === 0)
+                continue;
+            if (!changedFileData.has(curFile))
+                changedFileData.set(curFile, { ranges: [], addedLines: new Map() });
+            changedFileData.get(curFile).ranges.push([newLineNum, newLineNum + count - 1]);
+            continue;
+        }
+        if (!curFile || !changedFileData.has(curFile))
+            continue;
+        if (line.startsWith('+') && !line.startsWith('+++')) {
+            changedFileData.get(curFile).addedLines.set(newLineNum++, line.slice(1));
+        }
+        // '-' lines don't advance new-file position; no context lines with --unified=0
+    }
+    // Backward-compat: changedLines used by the node-overlap loop below
+    const changedLines = new Map([...changedFileData.entries()].map(([k, v]) => [k, v.ranges]));
+    const cg = ctx.callGraph;
+    const nodeMap = new Map(cg.nodes.map(n => [n.id, n]));
+    // Map changed line ranges to function nodes; track overlapping line count per function
+    const changedFnIds = new Set();
+    const fnChangedLineCount = new Map(); // nodeId → #lines overlapping with diff
+    for (const [filePath, ranges] of changedLines) {
+        const fileNodes = cg.nodes.filter(n => n.filePath === filePath && !n.isExternal && !n.isTest && n.startLine);
+        for (const node of fileNodes) {
+            const fnEnd = node.endLine ?? node.startLine;
+            let overlap = 0;
+            for (const [start, end] of ranges) {
+                if (node.startLine <= end && fnEnd >= start) {
+                    changedFnIds.add(node.id);
+                    overlap += Math.min(end, fnEnd) - Math.max(start, node.startLine) + 1;
+                }
+            }
+            if (overlap > 0)
+                fnChangedLineCount.set(node.id, (fnChangedLineCount.get(node.id) ?? 0) + overlap);
+        }
+        // Fallback: no line match — include all functions in the file
+        if (fileNodes.length > 0 && !fileNodes.some(n => changedFnIds.has(n.id))) {
+            for (const n of fileNodes)
+                changedFnIds.add(n.id);
+        }
+    }
+    if (changedFnIds.size === 0) {
+        return { changedFunctions: [], message: 'Changed files found but no matching function nodes. Re-run analyze_codebase.' };
+    }
+    const callsEdges = cg.edges.filter(e => !e.kind || e.kind === 'calls');
+    // callerIndex: calleeId → [{id, callType}] — callType weights BFS contribution
+    const callerIndex = new Map();
+    for (const e of callsEdges) {
+        if (!callerIndex.has(e.calleeId))
+            callerIndex.set(e.calleeId, []);
+        callerIndex.get(e.calleeId).push({ id: e.callerId, callType: e.callType });
+    }
+    // calleeIndex: callerId → calleeIds (for boundary score)
+    const calleeIndex = new Map();
+    for (const e of callsEdges) {
+        if (!calleeIndex.has(e.callerId))
+            calleeIndex.set(e.callerId, []);
+        calleeIndex.get(e.callerId).push(e.calleeId);
+    }
+    // awaited callers most sensitive; callback least (detached, survives interface change)
+    const callTypeWeight = (ct) => ct === 'awaited' ? 1.0 : ct === 'direct' ? 0.7 : ct === 'method' ? 0.6 :
+        ct === 'callback' ? 0.4 : 0.5; // 0.5 default covers 'constructor' and unknown
+    // Distance-weighted BFS: Σ weight/d² — clamped to prevent cross-repo drift
+    const transitiveScore = (startId) => {
+        const visited = new Set();
+        const queue = [{ id: startId, depth: 1 }];
+        let score = 0;
+        while (queue.length) {
+            const { id, depth } = queue.shift();
+            for (const caller of callerIndex.get(id) ?? []) {
+                if (!visited.has(caller.id)) {
+                    visited.add(caller.id);
+                    score += callTypeWeight(caller.callType) / (depth * depth);
+                    queue.push({ id: caller.id, depth: depth + 1 });
+                }
+            }
+        }
+        return Math.min(score, TRANSITIVE_SCORE_MAX);
+    };
+    // Boundary score: outgoing edges to external nodes; http/db weighted 3×, others 1×; normalized
+    const boundaryScore = (nodeId) => {
+        let raw = 0;
+        for (const calleeId of calleeIndex.get(nodeId) ?? []) {
+            const callee = nodeMap.get(calleeId);
+            if (!callee?.isExternal)
+                continue;
+            raw += (callee.externalKind === 'http' || callee.externalKind === 'database') ? 3 : 1;
+        }
+        return Math.min(raw / 3, 1);
+    };
+    // testedBy map: nodeId → [{name, confidence}]
+    const testedByMap = new Map();
+    for (const e of cg.edges.filter(e => e.kind === 'tested_by')) {
+        if (!testedByMap.has(e.callerId))
+            testedByMap.set(e.callerId, []);
+        const arr = testedByMap.get(e.callerId);
+        if (!arr.some(x => x.name === e.calleeName)) {
+            arr.push({ name: e.calleeName, confidence: e.confidence === 'import' ? 'imported' : 'called' });
+        }
+    }
+    const scored = [...changedFnIds].map(id => {
+        const n = nodeMap.get(id);
+        const fnLength = Math.max(1, (n.endLine ?? n.startLine ?? 1) - (n.startLine ?? 1) + 1);
+        const changed = fnChangedLineCount.get(id) ?? Math.round(fnLength * 0.5);
+        // Blend relative (sensitivity) + absolute (log scale) — prevents tiny fully-changed fns
+        // from outranking large ones; log(201)≈5.3 so 200 changed lines ≈ absScore 1.0
+        const relScore = changed / fnLength;
+        const absScore = Math.log(1 + changed) / Math.log(201);
+        const rawChangeScore = Math.min(0.6 * relScore + 0.4 * absScore, 1);
+        // Semantic modifier: signature changes are higher risk than config/literal tweaks
+        const changeType = classifyChangeType(n, changedFileData.get(n.filePath)?.addedLines ?? new Map());
+        const changeScore = Math.min(rawChangeScore * CHANGE_TYPE_MULTIPLIER[changeType], 1);
+        const tests = testedByMap.get(id) ?? [];
+        // called-edges are direct proof; imported-only is weaker (survives vi.mock)
+        const effectiveTests = tests.reduce((s, t) => s + (t.confidence === 'called' ? 1.0 : 0.3), 0);
+        const coveragePenalty = 1 / (1 + Math.log(1 + effectiveTests));
+        const tScore = transitiveScore(id);
+        const bScore = boundaryScore(id);
+        // Multiplicative model: risk = likelihood × impact
+        // Decouples change probability from structural blast radius; prevents correlated
+        // signals (fanIn ↔ transitive) from triple-stacking additively
+        const likelihood = changeScore * (1 + coveragePenalty);
+        const impact = Math.log(1 + n.fanIn) * 0.8 + tScore + bScore;
+        const riskScore = Math.round(likelihood * impact * 100) / 100;
+        const directCallers = callerIndex.get(id) ?? [];
+        const reason = buildReason({ changeType, directCallers, tests, bScore, fanIn: n.fanIn });
+        return {
+            name: n.name,
+            file: relative(absDir, n.filePath),
+            startLine: n.startLine ?? null,
+            endLine: n.endLine ?? null,
+            fanIn: n.fanIn,
+            blastRadius: Math.round(tScore * 100) / 100,
+            changeType,
+            riskScore,
+            reason,
+            testedBy: testedByMap.get(id) ?? [],
+        };
+    }).sort((a, b) => b.riskScore - a.riskScore);
+    return {
+        base: ref,
+        totalChanged: scored.length,
+        changedFunctions: scored,
+    };
+}
+//# sourceMappingURL=analysis.js.map