@kodus/kodus-graph 0.2.8 → 0.2.10

package/dist/analysis/diff.js

@@ -0,0 +1,155 @@
+import { log } from '../shared/logger';
+export function computeStructuralDiff(oldGraph, newNodes, newEdges, changedFiles) {
+    const changedSet = new Set(changedFiles);
+    // Old nodes in changed files
+    const oldNodesInChanged = new Map();
+    for (const n of oldGraph.nodes) {
+        if (changedSet.has(n.file_path)) {
+            oldNodesInChanged.set(n.qualified_name, n);
+        }
+    }
+    // New nodes in changed files
+    const newNodesMap = new Map();
+    for (const n of newNodes) {
+        if (changedSet.has(n.file_path)) {
+            newNodesMap.set(n.qualified_name, n);
+        }
+    }
+    log.debug('diff: input', {
+        oldNodesInChanged: oldNodesInChanged.size,
+        newNodesInChanged: newNodesMap.size,
+        changedFiles,
+    });
+    // Classify nodes
+    const added = [];
+    const removed = [];
+    const modified = [];
+    for (const [qn, n] of newNodesMap) {
+        if (!oldNodesInChanged.has(qn)) {
+            added.push({
+                qualified_name: qn,
+                kind: n.kind,
+                file_path: n.file_path,
+                line_start: n.line_start,
+                line_end: n.line_end,
+            });
+        }
+    }
+    for (const [qn, n] of oldNodesInChanged) {
+        if (!newNodesMap.has(qn)) {
+            removed.push({
+                qualified_name: qn,
+                kind: n.kind,
+                file_path: n.file_path,
+                line_start: n.line_start,
+                line_end: n.line_end,
+            });
+        }
+        else {
+            const newN = newNodesMap.get(qn);
+            const changes = [];
+            // Detect real content changes vs. pure displacement.
+            // content_hash = SHA256 of the node's source text (position-independent).
+            if (n.content_hash && newN.content_hash) {
+                // Definitive: hash comparison catches ALL content changes,
+                // even same-line-count edits (e.g. `return 1` → `return 2`).
+                if (n.content_hash !== newN.content_hash) {
+                    changes.push('body');
+                    log.debug('diff: body change detected', {
+                        node: qn,
+                        oldHash: n.content_hash.substring(0, 8),
+                        newHash: newN.content_hash.substring(0, 8),
+                    });
+                }
+                else {
+                    log.debug('diff: hash match (displacement only)', {
+                        node: qn,
+                        oldLines: `${n.line_start}-${n.line_end}`,
+                        newLines: `${newN.line_start}-${newN.line_end}`,
+                    });
+                }
+            }
+            else if (n.line_start !== newN.line_start || n.line_end !== newN.line_end) {
+                // Fallback (legacy data without content_hash): size heuristic.
+                const oldSize = n.line_end - n.line_start;
+                const newSize = newN.line_end - newN.line_start;
+                if (oldSize !== newSize) {
+                    changes.push('line_range');
+                    log.debug('diff: line_range fallback (no content_hash)', {
+                        node: qn,
+                        hasOldHash: !!n.content_hash,
+                        hasNewHash: !!newN.content_hash,
+                        oldSize,
+                        newSize,
+                    });
+                }
+            }
+            const contractDiffs = [];
+            if ((n.params || '') !== (newN.params || '')) {
+                changes.push('params');
+                contractDiffs.push({ field: 'params', old_value: n.params || '()', new_value: newN.params || '()' });
+            }
+            if ((n.return_type || '') !== (newN.return_type || '')) {
+                changes.push('return_type');
+                contractDiffs.push({
+                    field: 'return_type',
+                    old_value: n.return_type || 'void',
+                    new_value: newN.return_type || 'void',
+                });
+            }
+            if ((n.modifiers || '') !== (newN.modifiers || '')) {
+                changes.push('modifiers');
+                contractDiffs.push({
+                    field: 'modifiers',
+                    old_value: n.modifiers || '',
+                    new_value: newN.modifiers || '',
+                });
+            }
+            if (changes.length > 0) {
+                modified.push({ qualified_name: qn, changes, contract_diffs: contractDiffs });
+            }
+        }
+    }
+    // Classify edges
+    const oldEdgesInChanged = oldGraph.edges.filter((e) => changedSet.has(e.file_path));
+    const oldEdgeKeys = new Set(oldEdgesInChanged.map((e) => `${e.kind}|${e.source_qualified}|${e.target_qualified}`));
+    const newEdgesInChanged = newEdges.filter((e) => changedSet.has(e.file_path));
+    const newEdgeKeys = new Set(newEdgesInChanged.map((e) => `${e.kind}|${e.source_qualified}|${e.target_qualified}`));
+    const addedEdges = newEdgesInChanged
+        .filter((e) => !oldEdgeKeys.has(`${e.kind}|${e.source_qualified}|${e.target_qualified}`))
+        .map((e) => ({ kind: e.kind, source_qualified: e.source_qualified, target_qualified: e.target_qualified }));
+    const removedEdges = oldEdgesInChanged
+        .filter((e) => !newEdgeKeys.has(`${e.kind}|${e.source_qualified}|${e.target_qualified}`))
+        .map((e) => ({ kind: e.kind, source_qualified: e.source_qualified, target_qualified: e.target_qualified }));
+    // Risk by file: count unique dependents via reverse adjacency
+    const riskByFile = {};
+    for (const file of changedFiles) {
+        const nodesInFile = oldGraph.byFile.get(file) || [];
+        const dependents = new Set();
+        for (const n of nodesInFile) {
+            for (const edge of oldGraph.reverseAdjacency.get(n.qualified_name) || []) {
+                if (!changedSet.has(edge.file_path)) {
+                    dependents.add(edge.source_qualified);
+                }
+            }
+        }
+        const count = dependents.size;
+        const risk = count >= 10 ? 'HIGH' : count >= 3 ? 'MEDIUM' : 'LOW';
+        riskByFile[file] = { dependents: count, risk };
+    }
+    log.info('diff: result', {
+        added: added.length,
+        removed: removed.length,
+        modified: modified.length,
+        edgesAdded: addedEdges.length,
+        edgesRemoved: removedEdges.length,
+        modifiedDetails: modified.map((m) => `${m.qualified_name} [${m.changes.join(',')}]`),
+    });
+    return {
+        changed_files: changedFiles,
+        summary: { added: added.length, removed: removed.length, modified: modified.length },
+        nodes: { added, removed, modified },
+        edges: { added: addedEdges, removed: removedEdges },
+        risk_by_file: riskByFile,
+    };
+}

package/dist/analysis/enrich.d.ts

@@ -0,0 +1,5 @@
+import type { IndexedGraph } from '../graph/loader';
+import type { EnrichedFunction } from '../graph/types';
+import type { DiffResult } from './diff';
+import type { Flow } from './flows';
+export declare function enrichChangedFunctions(graph: IndexedGraph, changedFiles: string[], diff: DiffResult, allFlows: Flow[], minConfidence: number, onlyChanged?: boolean): EnrichedFunction[];

package/dist/analysis/enrich.js

@@ -0,0 +1,126 @@
+export function enrichChangedFunctions(graph, changedFiles, diff, allFlows, minConfidence, onlyChanged = false) {
+    const changedSet = new Set(changedFiles);
+    // Pre-index diff results
+    const addedSet = new Set(diff.nodes.added.map((n) => n.qualified_name));
+    const modifiedMap = new Map(diff.nodes.modified.map((m) => [m.qualified_name, m]));
+    // Pre-index TESTED_BY
+    const testedFiles = new Set(graph.edges.filter((e) => e.kind === 'TESTED_BY').map((e) => e.source_qualified));
+    // Pre-index flows by function
+    const flowsByFunction = new Map();
+    for (const flow of allFlows) {
+        for (const qn of flow.path) {
+            const list = flowsByFunction.get(qn);
+            if (list) {
+                if (!list.includes(flow.entry_point)) {
+                    list.push(flow.entry_point);
+                }
+            }
+            else {
+                flowsByFunction.set(qn, [flow.entry_point]);
+            }
+        }
+    }
+    // Filter functions in changed files
+    const changedFunctions = graph.nodes.filter((n) => {
+        if (!changedSet.has(n.file_path)) {
+            return false;
+        }
+        if (n.is_test ||
+            n.kind === 'Constructor' ||
+            n.kind === 'Class' ||
+            n.kind === 'Interface' ||
+            n.kind === 'Enum') {
+            return false;
+        }
+        if (onlyChanged) {
+            return addedSet.has(n.qualified_name) || modifiedMap.has(n.qualified_name);
+        }
+        return true;
+    });
+    return changedFunctions
+        .sort((a, b) => a.file_path.localeCompare(b.file_path) || a.line_start - b.line_start)
+        .map((node) => {
+        // Callers
+        const callers = [];
+        for (const edge of graph.reverseAdjacency.get(node.qualified_name) || []) {
+            if (edge.kind !== 'CALLS') {
+                continue;
+            }
+            // null/undefined confidence = high confidence (edge came from DB or parser without scoring)
+            if ((edge.confidence ?? 1.0) < minConfidence) {
+                continue;
+            }
+            const sourceNode = graph.byQualified.get(edge.source_qualified);
+            callers.push({
+                qualified_name: edge.source_qualified,
+                name: sourceNode?.name || edge.source_qualified.split('::').pop() || 'unknown',
+                file_path: sourceNode?.file_path || edge.file_path,
+                line: edge.line,
+                confidence: edge.confidence ?? 1.0,
+            });
+        }
+        // Callees
+        const callees = [];
+        const seenCallees = new Set();
+        for (const edge of graph.adjacency.get(node.qualified_name) || []) {
+            if (edge.kind !== 'CALLS') {
+                continue;
+            }
+            if (seenCallees.has(edge.target_qualified)) {
+                continue;
+            }
+            seenCallees.add(edge.target_qualified);
+            const targetNode = graph.byQualified.get(edge.target_qualified);
+            const name = targetNode?.name || edge.target_qualified.split('::').pop() || 'unknown';
+            const params = targetNode?.params && targetNode.params !== '()' ? targetNode.params : '';
+            const ret = targetNode?.return_type ? ` -> ${targetNode.return_type}` : '';
+            callees.push({
+                qualified_name: edge.target_qualified,
+                name,
+                file_path: targetNode?.file_path || '',
+                signature: `${name}${params}${ret}`,
+            });
+        }
+        // Signature
+        const shortName = node.name.includes('.') ? node.name.split('.').pop() : node.name;
+        const params = node.params && node.params !== '()' ? node.params : '';
+        const ret = node.return_type ? ` -> ${node.return_type}` : '';
+        const signature = `${shortName}${params}${ret}`;
+        // Diff
+        const isNew = addedSet.has(node.qualified_name);
+        const modifiedNode = modifiedMap.get(node.qualified_name);
+        const diffChanges = isNew ? [] : modifiedNode?.changes || [];
+        const contractDiffs = isNew ? [] : (modifiedNode?.contract_diffs ?? []);
+        // Caller impact
+        let callerImpact;
+        if (contractDiffs.length > 0 && callers.length > 0) {
+            const impacts = [];
+            const paramsDiff = contractDiffs.find((d) => d.field === 'params');
+            const returnDiff = contractDiffs.find((d) => d.field === 'return_type');
+            if (paramsDiff) {
+                impacts.push(`${callers.length} callers may need param update`);
+            }
+            if (returnDiff) {
+                impacts.push(`${callers.length} callers may assume old return type`);
+            }
+            callerImpact = impacts.length > 0 ? impacts.join('; ') : undefined;
+        }
+        return {
+            qualified_name: node.qualified_name,
+            name: node.name,
+            kind: node.kind,
+            signature,
+            file_path: node.file_path,
+            line_start: node.line_start,
+            line_end: node.line_end,
+            callers,
+            callees,
+            has_test_coverage: testedFiles.has(node.file_path),
+            diff_changes: diffChanges,
+            contract_diffs: contractDiffs,
+            caller_impact: callerImpact,
+            is_new: isNew,
+            in_flows: flowsByFunction.get(node.qualified_name) || [],
+        };
+    });
+}

package/dist/analysis/flows.d.ts

@@ -0,0 +1,27 @@
+import type { IndexedGraph } from '../graph/loader';
+export interface FlowOptions {
+    maxDepth: number;
+    type: 'test' | 'http' | 'all';
+}
+export interface Flow {
+    entry_point: string;
+    type: 'test' | 'http';
+    depth: number;
+    node_count: number;
+    file_count: number;
+    criticality: number;
+    path: string[];
+}
+export interface FlowsResult {
+    flows: Flow[];
+    summary: {
+        total_flows: number;
+        by_type: {
+            test: number;
+            http: number;
+        };
+        avg_depth: number;
+        max_criticality: number;
+    };
+}
+export declare function detectFlows(graph: IndexedGraph, opts: FlowOptions): FlowsResult;

package/dist/analysis/flows.js

@@ -0,0 +1,86 @@
+const HTTP_METHOD_NAMES = new Set(['get', 'post', 'put', 'delete', 'patch', 'handle', 'handler']);
+function isHttpHandler(_qualifiedName, name, parentName) {
+    if (HTTP_METHOD_NAMES.has(name.toLowerCase())) {
+        return true;
+    }
+    if (parentName?.toLowerCase().endsWith('controller')) {
+        return true;
+    }
+    return false;
+}
+export function detectFlows(graph, opts) {
+    const { maxDepth, type } = opts;
+    // Find entry points
+    const entryPoints = [];
+    for (const node of graph.nodes) {
+        if (type !== 'http' && node.kind === 'Test') {
+            entryPoints.push({ qualified: node.qualified_name, type: 'test' });
+        }
+        if (type !== 'test' && (node.kind === 'Method' || node.kind === 'Function')) {
+            if (isHttpHandler(node.qualified_name, node.name, node.parent_name)) {
+                entryPoints.push({ qualified: node.qualified_name, type: 'http' });
+            }
+        }
+    }
+    // BFS for each entry point
+    const flows = [];
+    for (const ep of entryPoints) {
+        const path = [ep.qualified];
+        const visited = new Set([ep.qualified]);
+        const files = new Set();
+        const startNode = graph.byQualified.get(ep.qualified);
+        if (startNode) {
+            files.add(startNode.file_path);
+        }
+        let frontier = [ep.qualified];
+        let depth = 0;
+        while (frontier.length > 0 && depth < maxDepth) {
+            const next = [];
+            for (const q of frontier) {
+                for (const edge of graph.adjacency.get(q) || []) {
+                    if (edge.kind !== 'CALLS') {
+                        continue;
+                    }
+                    if (visited.has(edge.target_qualified)) {
+                        continue;
+                    }
+                    visited.add(edge.target_qualified);
+                    next.push(edge.target_qualified);
+                    path.push(edge.target_qualified);
+                    const targetNode = graph.byQualified.get(edge.target_qualified);
+                    if (targetNode) {
+                        files.add(targetNode.file_path);
+                    }
+                }
+            }
+            if (next.length === 0) {
+                break;
+            }
+            frontier = next;
+            depth++;
+        }
+        flows.push({
+            entry_point: ep.qualified,
+            type: ep.type,
+            depth,
+            node_count: visited.size,
+            file_count: files.size,
+            criticality: visited.size * files.size,
+            path,
+        });
+    }
+    flows.sort((a, b) => b.criticality - a.criticality);
+    const testFlows = flows.filter((f) => f.type === 'test').length;
+    const httpFlows = flows.filter((f) => f.type === 'http').length;
+    const avgDepth = flows.length > 0 ? Math.round((flows.reduce((s, f) => s + f.depth, 0) / flows.length) * 10) / 10 : 0;
+    const maxCriticality = flows.length > 0 ? flows[0].criticality : 0;
+    return {
+        flows,
+        summary: {
+            total_flows: flows.length,
+            by_type: { test: testFlows, http: httpFlows },
+            avg_depth: avgDepth,
+            max_criticality: maxCriticality,
+        },
+    };
+}

package/dist/analysis/inheritance.d.ts

@@ -0,0 +1,3 @@
+import type { IndexedGraph } from '../graph/loader';
+import type { InheritanceEntry } from '../graph/types';
+export declare function extractInheritance(graph: IndexedGraph, changedFiles: string[]): InheritanceEntry[];

package/dist/analysis/inheritance.js

@@ -0,0 +1,31 @@
+export function extractInheritance(graph, changedFiles) {
+    const changedSet = new Set(changedFiles);
+    const entries = [];
+    const changedClasses = graph.nodes.filter((n) => changedSet.has(n.file_path) && n.kind === 'Class');
+    for (const cls of changedClasses) {
+        let extendsClass;
+        const implementsList = [];
+        const children = [];
+        for (const edge of graph.adjacency.get(cls.qualified_name) || []) {
+            if (edge.kind === 'INHERITS') {
+                extendsClass = edge.target_qualified;
+            }
+            if (edge.kind === 'IMPLEMENTS') {
+                implementsList.push(edge.target_qualified);
+            }
+        }
+        for (const edge of graph.reverseAdjacency.get(cls.qualified_name) || []) {
+            if (edge.kind === 'INHERITS') {
+                children.push(edge.source_qualified);
+            }
+        }
+        entries.push({
+            qualified_name: cls.qualified_name,
+            file_path: cls.file_path,
+            extends: extendsClass,
+            implements: implementsList,
+            children,
+        });
+    }
+    return entries;
+}

package/dist/analysis/prompt-formatter.d.ts

@@ -0,0 +1,2 @@
+import type { ContextV2Output } from './context-builder';
+export declare function formatPrompt(output: ContextV2Output): string;

package/dist/analysis/prompt-formatter.js

@@ -0,0 +1,173 @@
+export function formatPrompt(output) {
+    const { analysis } = output;
+    const lines = [];
+    // Header
+    const risk = analysis.risk;
+    const br = analysis.blast_radius;
+    const meta = analysis.metadata;
+    lines.push('# Code Review Context');
+    lines.push('');
+    lines.push(`Risk: ${risk.level} (${risk.score}) | ${br.total_functions} functions impacted across ${br.total_files} files | ${meta.untested_count} untested`);
+    lines.push('');
+    // Changed functions
+    if (analysis.changed_functions.length > 0) {
+        lines.push('## Changed Functions');
+        lines.push('');
+        for (const fn of analysis.changed_functions) {
+            lines.push(`### ${fn.signature}  [${fn.file_path}:${fn.line_start}-${fn.line_end}]`);
+            // Status
+            if (fn.is_new) {
+                lines.push('Status: new');
+            }
+            else if (fn.diff_changes.length > 0) {
+                lines.push('Status: modified');
+                lines.push(`  Changes: ${fn.diff_changes.join(', ')}`);
+                for (const cd of fn.contract_diffs) {
+                    lines.push(`  - ${cd.field}: ${cd.old_value} -> ${cd.new_value}`);
+                }
+                if (fn.caller_impact) {
+                    lines.push(`  Impact: ${fn.caller_impact}`);
+                }
+            }
+            else {
+                lines.push('Status: unchanged');
+            }
+            // Callers
+            if (fn.callers.length > 0) {
+                lines.push('Callers:');
+                for (const c of fn.callers) {
+                    const conf = c.confidence < 0.85 ? ` confidence=${c.confidence.toFixed(2)}` : '';
+                    lines.push(`  - ${c.name}  [${c.file_path}:${c.line}]${conf}`);
+                }
+            }
+            else {
+                lines.push('Callers: none');
+            }
+            // Callees
+            if (fn.callees.length > 0) {
+                lines.push('Callees:');
+                for (const c of fn.callees) {
+                    lines.push(`  - ${c.signature}  [${c.file_path}]`);
+                }
+            }
+            else {
+                lines.push('Callees: none');
+            }
+            // Test coverage
+            lines.push(`Test coverage: ${fn.has_test_coverage ? 'yes' : 'no'}`);
+            // Affected flows
+            if (fn.in_flows.length > 0) {
+                lines.push('Affected flows:');
+                for (const ep of fn.in_flows) {
+                    const flow = analysis.affected_flows.find((f) => f.entry_point === ep);
+                    if (flow) {
+                        const prefix = flow.type === 'http' ? 'HTTP' : 'TEST';
+                        lines.push(`  - ${prefix}: ${flow.path.map((q) => q.split('::').pop()).join(' → ')}`);
+                    }
+                    else {
+                        lines.push(`  - ${ep.split('::').pop()}`);
+                    }
+                }
+            }
+            else {
+                lines.push('Affected flows: none');
+            }
+            lines.push('');
+        }
+    }
+    // Inheritance
+    if (analysis.inheritance.length > 0) {
+        lines.push('## Inheritance');
+        lines.push('');
+        for (const entry of analysis.inheritance) {
+            const name = entry.qualified_name.split('::').pop();
+            const parts = [];
+            if (entry.extends) {
+                parts.push(`extends ${entry.extends.split('::').pop()}`);
+            }
+            if (entry.implements.length > 0) {
+                parts.push(`implements ${entry.implements.map((i) => i.split('::').pop()).join(', ')}`);
+            }
+            lines.push(`- ${name} ${parts.join(', ')}`);
+            if (entry.children.length > 0) {
+                lines.push(`  Children: ${entry.children.map((c) => c.split('::').pop()).join(', ')}`);
+            }
+        }
+        lines.push('');
+    }
+    // Blast radius by depth
+    const byDepth = analysis.blast_radius.by_depth;
+    const depthKeys = Object.keys(byDepth).sort();
+    if (depthKeys.length > 0) {
+        lines.push('## Blast Radius');
+        lines.push('');
+        for (const depth of depthKeys) {
+            const names = byDepth[depth].map((q) => q.split('::').pop());
+            lines.push(`Depth ${depth}: ${names.join(', ')} (${names.length} functions)`);
+        }
+        lines.push('');
+    }
+    // Test gaps
+    if (analysis.test_gaps.length > 0) {
+        lines.push('## Test Gaps');
+        lines.push('');
+        for (const gap of analysis.test_gaps) {
+            const name = gap.function.split('::').pop();
+            lines.push(`- ${name}  [${gap.file_path}:${gap.line_start}]`);
+        }
+        lines.push('');
+    }
+    // Structural diff
+    const diff = analysis.structural_diff;
+    const hasNodeChanges = diff.summary.added > 0 || diff.summary.removed > 0 || diff.summary.modified > 0;
+    const hasEdgeChanges = diff.edges.added.length > 0 || diff.edges.removed.length > 0;
+    if (hasNodeChanges || hasEdgeChanges) {
+        lines.push('## Structural Changes');
+        lines.push('');
+        if (hasNodeChanges) {
+            const parts = [];
+            if (diff.summary.added > 0) {
+                parts.push(`${diff.summary.added} added`);
+            }
+            if (diff.summary.removed > 0) {
+                parts.push(`${diff.summary.removed} removed`);
+            }
+            if (diff.summary.modified > 0) {
+                parts.push(`${diff.summary.modified} modified`);
+            }
+            lines.push(parts.join(', '));
+        }
+        if (diff.nodes.removed.length > 0) {
+            lines.push('');
+            lines.push('Removed:');
+            for (const n of diff.nodes.removed) {
+                const name = n.qualified_name.split('::').pop();
+                lines.push(`  - [${n.kind}] ${name}  [${n.file_path}:${n.line_start}]`);
+            }
+        }
+        if (diff.nodes.modified.length > 0) {
+            lines.push('');
+            lines.push('Modified:');
+            for (const m of diff.nodes.modified) {
+                const name = m.qualified_name.split('::').pop();
+                lines.push(`  - ${name} (${m.changes.join(', ')})`);
+            }
+        }
+        if (hasEdgeChanges) {
+            lines.push('');
+            lines.push('Dependency changes:');
+            for (const e of diff.edges.added) {
+                const src = e.source_qualified.split('::').pop();
+                const tgt = e.target_qualified.split('::').pop();
+                lines.push(`  + ${e.kind}: ${src} → ${tgt}`);
+            }
+            for (const e of diff.edges.removed) {
+                const src = e.source_qualified.split('::').pop();
+                const tgt = e.target_qualified.split('::').pop();
+                lines.push(`  - ${e.kind}: ${src} → ${tgt}`);
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}

package/dist/analysis/risk-score.d.ts

@@ -0,0 +1,4 @@
+import type { BlastRadiusResult, GraphData, RiskScoreResult } from '../graph/types';
+export declare function computeRiskScore(graph: GraphData, changedFiles: string[], blastRadius: BlastRadiusResult, options?: {
+    skipTests?: boolean;
+}): RiskScoreResult;

package/dist/analysis/risk-score.js

@@ -0,0 +1,51 @@
+export function computeRiskScore(graph, changedFiles, blastRadius, options) {
+    const changedSet = new Set(changedFiles);
+    const changedNodes = graph.nodes.filter((n) => changedSet.has(n.file_path) && !n.is_test);
+    // Factor 1: Blast radius (0.35)
+    const brValue = Math.min(blastRadius.total_functions / 20, 1); // cap at 20
+    // Factor 2: Test gaps (0.30) — skipped when test detection is disabled
+    let tgValue = 0;
+    let untestedCount = 0;
+    const changedFunctions = changedNodes.filter((n) => n.kind === 'Function' || n.kind === 'Method');
+    if (!options?.skipTests) {
+        const testedFiles = new Set(graph.edges.filter((e) => e.kind === 'TESTED_BY').map((e) => e.source_qualified));
+        untestedCount = changedFunctions.filter((n) => !testedFiles.has(n.file_path)).length;
+        tgValue = changedFunctions.length > 0 ? untestedCount / changedFunctions.length : 0;
+    }
+    // Factor 3: Complexity (0.20)
+    const avgSize = changedNodes.length > 0
+        ? changedNodes.reduce((s, n) => s + (n.line_end - n.line_start), 0) / changedNodes.length
+        : 0;
+    const cxValue = Math.min(avgSize / 50, 1); // cap at 50 lines
+    // Factor 4: Inheritance (0.15)
+    const hasInheritance = graph.edges.some((e) => (e.kind === 'INHERITS' || e.kind === 'IMPLEMENTS') && changedSet.has(e.file_path));
+    const ihValue = hasInheritance ? 1 : 0;
+    const score = brValue * 0.35 + tgValue * 0.3 + cxValue * 0.2 + ihValue * 0.15;
+    const level = score >= 0.6 ? 'HIGH' : score >= 0.3 ? 'MEDIUM' : 'LOW';
+    return {
+        level,
+        score: Math.round(score * 100) / 100,
+        factors: {
+            blast_radius: {
+                weight: 0.35,
+                value: Math.round(brValue * 100) / 100,
+                detail: `${blastRadius.total_functions} functions, ${blastRadius.total_files} files`,
+            },
+            test_gaps: {
+                weight: 0.3,
+                value: Math.round(tgValue * 100) / 100,
+                detail: `${untestedCount}/${changedFunctions.length} untested`,
+            },
+            complexity: {
+                weight: 0.2,
+                value: Math.round(cxValue * 100) / 100,
+                detail: `avg ${Math.round(avgSize)} lines`,
+            },
+            inheritance: {
+                weight: 0.15,
+                value: ihValue,
+                detail: hasInheritance ? 'has inheritance' : 'no inheritance',
+            },
+        },
+    };
+}