@kodus/kodus-graph 0.1.0

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@kodus/kodus-graph",
+  "version": "0.1.0",
+  "description": "Code graph builder for Kodus code review — parses source code into structural graphs with nodes, edges, and analysis",
+  "type": "module",
+  "bin": {
+    "kodus-graph": "./src/cli.ts"
+  },
+  "files": [
+    "src/**/*.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "bun run src/cli.ts",
+    "test": "bun test",
+    "lint": "biome check src/ tests/",
+    "lint:fix": "biome check --write src/ tests/",
+    "format": "biome format --write src/ tests/",
+    "typecheck": "tsc --noEmit",
+    "check": "bun run typecheck && bun run lint && bun test",
+    "build": "bun build src/cli.ts --compile --outfile kodus-graph",
+    "build:all": "bun run build:darwin-arm64 && bun run build:darwin-x64 && bun run build:linux-x64 && bun run build:linux-arm64",
+    "build:darwin-arm64": "bun build src/cli.ts --compile --target=bun-darwin-arm64 --outfile dist/kodus-graph-darwin-arm64",
+    "build:darwin-x64": "bun build src/cli.ts --compile --target=bun-darwin-x64 --outfile dist/kodus-graph-darwin-x64",
+    "build:linux-x64": "bun build src/cli.ts --compile --target=bun-linux-x64 --outfile dist/kodus-graph-linux-x64",
+    "build:linux-arm64": "bun build src/cli.ts --compile --target=bun-linux-arm64 --outfile dist/kodus-graph-linux-arm64"
+  },
+  "keywords": [
+    "code-graph",
+    "ast",
+    "code-review",
+    "static-analysis",
+    "kodus"
+  ],
+  "author": "Kodus AI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kodustech/kodus-graph.git"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "dependencies": {
+    "@ast-grep/lang-csharp": "^0.0.6",
+    "@ast-grep/lang-go": "^0.0.6",
+    "@ast-grep/lang-java": "^0.0.7",
+    "@ast-grep/lang-php": "^0.0.7",
+    "@ast-grep/lang-python": "^0.0.6",
+    "@ast-grep/lang-ruby": "^0.0.7",
+    "@ast-grep/lang-rust": "^0.0.7",
+    "@ast-grep/napi": "^0.42.0",
+    "commander": "^12.0.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.10",
+    "@types/bun": "latest",
+    "typescript": "^5.5.0"
+  }
+}

package/src/analysis/blast-radius.ts

@@ -0,0 +1,54 @@
+import type { BlastRadiusResult, GraphData } from '../graph/types';
+
+export function computeBlastRadius(graph: GraphData, changedFiles: string[], maxDepth: number = 2): BlastRadiusResult {
+  // Build adjacency list from CALLS edges (callers of changed nodes)
+  const adj = new Map<string, Set<string>>();
+  for (const edge of graph.edges) {
+    if (edge.kind !== 'CALLS' && edge.kind !== 'IMPORTS') continue;
+    // Reverse direction: target -> source (who calls/imports this?)
+    if (!adj.has(edge.target_qualified)) adj.set(edge.target_qualified, new Set());
+    adj.get(edge.target_qualified)!.add(edge.source_qualified);
+    // Forward direction too for IMPORTS
+    if (edge.kind === 'IMPORTS') {
+      if (!adj.has(edge.source_qualified)) adj.set(edge.source_qualified, new Set());
+      adj.get(edge.source_qualified)!.add(edge.target_qualified);
+    }
+  }
+
+  // Seed: all nodes in changed files
+  const changedSet = new Set(changedFiles);
+  const seeds = graph.nodes.filter((n) => changedSet.has(n.file_path)).map((n) => n.qualified_name);
+
+  // BFS
+  const visited = new Set<string>(seeds);
+  const byDepth: Record<string, string[]> = {};
+  let frontier = seeds;
+
+  for (let depth = 1; depth <= maxDepth; depth++) {
+    const next: string[] = [];
+    for (const node of frontier) {
+      for (const neighbor of adj.get(node) || []) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          next.push(neighbor);
+        }
+      }
+    }
+    if (next.length > 0) byDepth[String(depth)] = next;
+    frontier = next;
+  }
+
+  // Count unique files
+  const nodeIndex = new Map(graph.nodes.map((n) => [n.qualified_name, n]));
+  const impactedFiles = new Set<string>();
+  for (const q of visited) {
+    const node = nodeIndex.get(q);
+    if (node) impactedFiles.add(node.file_path);
+  }
+
+  return {
+    total_functions: visited.size,
+    total_files: impactedFiles.size,
+    by_depth: byDepth,
+  };
+}

package/src/analysis/communities.ts

@@ -0,0 +1,135 @@
+import type { IndexedGraph } from '../graph/loader';
+
+export interface CommunityOptions {
+  depth: number;
+  minSize: number;
+}
+
+export interface Community {
+  name: string;
+  files: string[];
+  node_count: number;
+  cohesion: number;
+  language: string;
+}
+
+export interface CouplingPair {
+  source: string;
+  target: string;
+  edges: number;
+  strength: 'HIGH' | 'MEDIUM' | 'LOW';
+}
+
+export interface CommunitiesResult {
+  communities: Community[];
+  coupling: CouplingPair[];
+  summary: { total_communities: number; avg_cohesion: number; high_coupling_pairs: number };
+}
+
+function getCommunityKey(filePath: string, depth: number): string {
+  const parts = filePath.split('/');
+  return parts.slice(0, depth).join('/');
+}
+
+export function detectCommunities(graph: IndexedGraph, opts: CommunityOptions): CommunitiesResult {
+  const { depth, minSize } = opts;
+
+  // Group nodes by directory
+  const groups = new Map<string, Set<string>>(); // community -> files
+  const nodeComm = new Map<string, string>(); // qualified_name -> community
+
+  for (const node of graph.nodes) {
+    const key = getCommunityKey(node.file_path, depth);
+    if (!groups.has(key)) groups.set(key, new Set());
+    groups.get(key)!.add(node.file_path);
+    nodeComm.set(node.qualified_name, key);
+  }
+
+  // Count internal and cross edges per community pair
+  const internalEdges = new Map<string, number>();
+  const crossEdges = new Map<string, number>(); // "a|b" -> count
+
+  for (const edge of graph.edges) {
+    if (edge.kind !== 'CALLS' && edge.kind !== 'IMPORTS') continue;
+    const srcComm = nodeComm.get(edge.source_qualified);
+    const tgtComm = nodeComm.get(edge.target_qualified);
+    if (!srcComm || !tgtComm) continue;
+
+    if (srcComm === tgtComm) {
+      internalEdges.set(srcComm, (internalEdges.get(srcComm) || 0) + 1);
+    } else {
+      const pairKey = [srcComm, tgtComm].sort().join('|');
+      crossEdges.set(pairKey, (crossEdges.get(pairKey) || 0) + 1);
+    }
+  }
+
+  // Build communities
+  const communities: Community[] = [];
+  for (const [name, files] of groups) {
+    const nodeCount = graph.nodes.filter((n) => getCommunityKey(n.file_path, depth) === name).length;
+    if (nodeCount < minSize) continue;
+
+    const internal = internalEdges.get(name) || 0;
+    const maxPossible = nodeCount * (nodeCount - 1);
+    const cohesion = maxPossible > 0 ? Math.round((internal / maxPossible) * 100) / 100 : 0;
+
+    const langs = new Map<string, number>();
+    for (const n of graph.nodes) {
+      if (getCommunityKey(n.file_path, depth) === name) {
+        langs.set(n.language, (langs.get(n.language) || 0) + 1);
+      }
+    }
+    let dominant = 'unknown';
+    let maxCount = 0;
+    for (const [lang, count] of langs) {
+      if (count > maxCount) {
+        dominant = lang;
+        maxCount = count;
+      }
+    }
+
+    communities.push({
+      name,
+      files: [...files].sort(),
+      node_count: nodeCount,
+      cohesion,
+      language: dominant,
+    });
+  }
+
+  communities.sort((a, b) => b.node_count - a.node_count);
+
+  // Build coupling pairs
+  const communityNames = new Set(communities.map((c) => c.name));
+  const coupling: CouplingPair[] = [];
+  for (const [pairKey, count] of crossEdges) {
+    const [src, tgt] = pairKey.split('|');
+    if (!communityNames.has(src) || !communityNames.has(tgt)) continue;
+
+    const srcTotal = graph.edges.filter((e) => {
+      const c = nodeComm.get(e.source_qualified);
+      return c === src || c === tgt;
+    }).length;
+    const ratio = srcTotal > 0 ? count / srcTotal : 0;
+    const strength = ratio > 0.3 ? 'HIGH' : ratio > 0.1 ? 'MEDIUM' : 'LOW';
+
+    coupling.push({ source: src, target: tgt, edges: count, strength });
+  }
+
+  coupling.sort((a, b) => b.edges - a.edges);
+
+  const avgCohesion =
+    communities.length > 0
+      ? Math.round((communities.reduce((s, c) => s + c.cohesion, 0) / communities.length) * 100) / 100
+      : 0;
+
+  return {
+    communities,
+    coupling,
+    summary: {
+      total_communities: communities.length,
+      avg_cohesion: avgCohesion,
+      high_coupling_pairs: coupling.filter((c) => c.strength === 'HIGH').length,
+    },
+  };
+}

package/src/analysis/diff.ts

@@ -0,0 +1,120 @@
+import type { IndexedGraph } from '../graph/loader';
+import type { GraphEdge, GraphNode } from '../graph/types';
+
+export interface NodeChange {
+  qualified_name: string;
+  kind: string;
+  file_path: string;
+  line_start: number;
+  line_end: number;
+}
+
+export interface ModifiedNode {
+  qualified_name: string;
+  changes: string[];
+}
+
+export interface DiffResult {
+  changed_files: string[];
+  summary: { added: number; removed: number; modified: number };
+  nodes: { added: NodeChange[]; removed: NodeChange[]; modified: ModifiedNode[] };
+  edges: {
+    added: Pick<GraphEdge, 'kind' | 'source_qualified' | 'target_qualified'>[];
+    removed: Pick<GraphEdge, 'kind' | 'source_qualified' | 'target_qualified'>[];
+  };
+  risk_by_file: Record<string, { dependents: number; risk: 'HIGH' | 'MEDIUM' | 'LOW' }>;
+}
+
+export function computeStructuralDiff(
+  oldGraph: IndexedGraph,
+  newNodes: GraphNode[],
+  newEdges: GraphEdge[],
+  changedFiles: string[],
+): DiffResult {
+  const changedSet = new Set(changedFiles);
+
+  // Old nodes in changed files
+  const oldNodesInChanged = new Map<string, GraphNode>();
+  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<string, GraphNode>();
+  for (const n of newNodes) {
+    if (changedSet.has(n.file_path)) newNodesMap.set(n.qualified_name, n);
+  }
+
+  // Classify nodes
+  const added: NodeChange[] = [];
+  const removed: NodeChange[] = [];
+  const modified: ModifiedNode[] = [];
+
+  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: string[] = [];
+      if (n.line_start !== newN.line_start || n.line_end !== newN.line_end) changes.push('line_range');
+      if ((n.params || '') !== (newN.params || '')) changes.push('params');
+      if ((n.return_type || '') !== (newN.return_type || '')) changes.push('return_type');
+      if (changes.length > 0) modified.push({ qualified_name: qn, changes });
+    }
+  }
+
+  // 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: Record<string, { dependents: number; risk: 'HIGH' | 'MEDIUM' | 'LOW' }> = {};
+  for (const file of changedFiles) {
+    const nodesInFile = oldGraph.byFile.get(file) || [];
+    const dependents = new Set<string>();
+    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 };
+  }
+
+  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/src/analysis/flows.ts

@@ -0,0 +1,112 @@
+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;
+  };
+}
+
+const HTTP_METHOD_NAMES = new Set(['get', 'post', 'put', 'delete', 'patch', 'handle', 'handler']);
+
+function isHttpHandler(_qualifiedName: string, name: string, parentName?: string): boolean {
+  if (HTTP_METHOD_NAMES.has(name.toLowerCase())) return true;
+  if (parentName?.toLowerCase().endsWith('controller')) return true;
+  return false;
+}
+
+export function detectFlows(graph: IndexedGraph, opts: FlowOptions): FlowsResult {
+  const { maxDepth, type } = opts;
+
+  // Find entry points
+  const entryPoints: { qualified: string; type: 'test' | 'http' }[] = [];
+
+  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: Flow[] = [];
+
+  for (const ep of entryPoints) {
+    const path: string[] = [ep.qualified];
+    const visited = new Set<string>([ep.qualified]);
+    const files = new Set<string>();
+
+    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: string[] = [];
+      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/src/analysis/review-context.ts

@@ -0,0 +1,141 @@
+import type { ContextOutput, GraphData } from '../graph/types';
+import { computeBlastRadius } from './blast-radius';
+import { computeRiskScore } from './risk-score';
+import { findTestGaps } from './test-gaps';
+
+export function buildReviewContext(graph: GraphData, changedFiles: string[]): ContextOutput {
+  const changedSet = new Set(changedFiles);
+  const lines: string[] = [];
+
+  // Build caller/callee index from CALLS edges
+  const callersOf = new Map<string, Array<{ name: string; file: string; line: number; confidence: number }>>();
+  const calleesOf = new Map<
+    string,
+    Array<{ name: string; target: string; file: string; line: number; confidence: number }>
+  >();
+
+  // Index nodes by qualified name
+  const nodeIndex = new Map(graph.nodes.map((n) => [n.qualified_name, n]));
+
+  for (const edge of graph.edges) {
+    if (edge.kind !== 'CALLS' || (edge.confidence ?? 0) < 0.5) continue;
+
+    // callers: who calls edge.target
+    if (!callersOf.has(edge.target_qualified)) callersOf.set(edge.target_qualified, []);
+    const sourceNode = nodeIndex.get(edge.source_qualified);
+    callersOf.get(edge.target_qualified)!.push({
+      name: sourceNode?.name || edge.source_qualified.split('::').pop() || 'unknown',
+      file: sourceNode?.file_path || edge.file_path,
+      line: edge.line,
+      confidence: edge.confidence || 0,
+    });
+
+    // callees: what does source call
+    if (!calleesOf.has(edge.source_qualified)) calleesOf.set(edge.source_qualified, []);
+    const targetNode = nodeIndex.get(edge.target_qualified);
+    calleesOf.get(edge.source_qualified)!.push({
+      name: targetNode?.name || edge.target_qualified.split('::').pop() || 'unknown',
+      target: edge.target_qualified,
+      file: targetNode?.file_path || '',
+      line: edge.line,
+      confidence: edge.confidence || 0,
+    });
+  }
+
+  // TESTED_BY index
+  const testedFiles = new Set(graph.edges.filter((e) => e.kind === 'TESTED_BY').map((e) => e.source_qualified));
+
+  lines.push('Changed functions (AST analysis):\n');
+
+  // Functions in changed files
+  const changedFunctions = graph.nodes
+    .filter(
+      (n) =>
+        changedSet.has(n.file_path) && !n.is_test && n.kind !== 'Class' && n.kind !== 'Interface' && n.kind !== 'Enum',
+    )
+    .sort((a, b) => a.file_path.localeCompare(b.file_path) || a.line_start - b.line_start);
+
+  let callerCount = 0;
+  let calleeCount = 0;
+
+  for (const func of changedFunctions) {
+    if (func.kind === 'Constructor') continue;
+
+    const shortName = func.name.includes('.') ? func.name.split('.').pop()! : func.name;
+    const sig = func.params && func.params !== '()' ? `${shortName}${func.params}` : shortName;
+    const ret = func.return_type ? ` -> ${func.return_type}` : '';
+    lines.push(`${sig}${ret}  (${func.file_path}:${func.line_start})`);
+
+    // Callers
+    const callers = callersOf.get(func.qualified_name) || [];
+    callerCount += callers.length;
+    for (const caller of callers.slice(0, 5)) {
+      const conf = caller.confidence >= 0.85 ? '' : ` [${Math.round(caller.confidence * 100)}%]`;
+      lines.push(`  ← called by ${caller.name} (${caller.file}:${caller.line})${conf}`);
+    }
+    if (callers.length > 5) lines.push(`  ← ... and ${callers.length - 5} more callers`);
+
+    // Callees
+    const callees = calleesOf.get(func.qualified_name) || [];
+    calleeCount += callees.length;
+    const seenCallees = new Set<string>();
+    for (const callee of callees.slice(0, 5)) {
+      if (seenCallees.has(callee.target)) continue;
+      seenCallees.add(callee.target);
+      const calleeNode = nodeIndex.get(callee.target);
+      if (calleeNode) {
+        const calleeSig =
+          calleeNode.params && calleeNode.params !== '()' ? `${callee.name}${calleeNode.params}` : callee.name;
+        const calleeRet = calleeNode.return_type ? ` -> ${calleeNode.return_type}` : '';
+        lines.push(`  → calls ${calleeSig}${calleeRet}  (${calleeNode.file_path}:${calleeNode.line_start})`);
+      } else {
+        lines.push(`  → calls ${callee.name}  (${callee.file || 'external'})`);
+      }
+    }
+
+    // Test coverage
+    if (testedFiles.has(func.file_path)) {
+      lines.push(`  ✅ has test coverage`);
+    } else {
+      lines.push(`  ⚠ NO TEST COVERAGE`);
+    }
+
+    lines.push('');
+  }
+
+  // Blast radius
+  const blastRadius = computeBlastRadius(graph, changedFiles);
+  if (blastRadius.total_files > changedFiles.length) {
+    lines.push(
+      `Blast radius: ${changedFunctions.filter((f) => f.kind !== 'Constructor').length} changed functions impact ${blastRadius.total_files - changedFiles.length} other files`,
+    );
+  }
+
+  // Risk score
+  const riskScore = computeRiskScore(graph, changedFiles, blastRadius);
+  lines.push(`\nRisk: ${riskScore.level} (${riskScore.score})`);
+
+  // Test gaps
+  const testGaps = findTestGaps(graph, changedFiles);
+  const untestedCount = testGaps.length;
+  if (untestedCount > 0) {
+    lines.push(`\n⚠ ${untestedCount} changed function(s) without test coverage:`);
+    for (const gap of testGaps.slice(0, 10)) {
+      const shortName = gap.function.split('::').pop() || gap.function;
+      lines.push(`  ${shortName} (${gap.file_path}:${gap.line_start})`);
+    }
+  }
+
+  return {
+    text: lines.join('\n'),
+    metadata: {
+      changed_functions: changedFunctions.filter((f) => f.kind !== 'Constructor').length,
+      caller_count: callerCount,
+      callee_count: calleeCount,
+      untested_count: untestedCount,
+      blast_radius: { functions: blastRadius.total_functions, files: blastRadius.total_files },
+      risk_level: riskScore.level,
+      risk_score: riskScore.score,
+    },
+  };
+}

package/src/analysis/risk-score.ts

@@ -0,0 +1,62 @@
+import type { BlastRadiusResult, GraphData, RiskScoreResult } from '../graph/types';
+
+export function computeRiskScore(
+  graph: GraphData,
+  changedFiles: string[],
+  blastRadius: BlastRadiusResult,
+): RiskScoreResult {
+  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)
+  const testedFiles = new Set(graph.edges.filter((e) => e.kind === 'TESTED_BY').map((e) => e.source_qualified));
+  const changedFunctions = changedNodes.filter((n) => n.kind === 'Function' || n.kind === 'Method');
+  const untestedCount = changedFunctions.filter((n) => !testedFiles.has(n.file_path)).length;
+  const 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',
+      },
+    },
+  };
+}