@mrciphersmith/keryx 0.2.9

package/src/gdgraph/treesitter/extract.test.ts

@@ -0,0 +1,278 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { expect, test } from "bun:test";
+import { extractSymbolLayer, type TsNode } from "./extract";
+import type { CallEdge, SymbolNode } from "../types";
+
+const FIXTURE_DIR = fileURLToPath(new URL("../../../fixtures/symbol-graph/", import.meta.url));
+
+// --- Minimal mock syntax-tree builder (a structural stand-in for a parsed
+// `web-tree-sitter` tree; the extractor is dependency-free). ---
+interface MockOptions {
+  type: string;
+  line?: number;
+  endLine?: number;
+  text?: string;
+  fields?: Record<string, TsNode | null>;
+  namedChildren?: TsNode[];
+}
+
+function mk(o: MockOptions): TsNode {
+  const line = o.line ?? 1;
+  const endLine = o.endLine ?? line;
+  const named = o.namedChildren ?? [];
+  return {
+    type: o.type,
+    text: o.text ?? "",
+    startPosition: { row: line - 1, column: 0 },
+    endPosition: { row: endLine - 1, column: 0 },
+    childForFieldName: (field: string) => o.fields?.[field] ?? null,
+    namedChildren: named,
+    children: named,
+  };
+}
+
+const idNode = (text: string): TsNode => mk({ type: "identifier", text });
+const paramsNode = (): TsNode => mk({ type: "formal_parameters", text: "()" });
+const callTo = (name: string, line: number): TsNode =>
+  mk({ type: "call_expression", line, fields: { function: idNode(name) }, text: `${name}()` });
+
+// Build the tree modeling `fixtures/symbol-graph/source.ts`.
+export function buildWidgetTree(): TsNode {
+  const alphaBody = mk({ type: "statement_block", line: 1, namedChildren: [callTo("helper", 1)] });
+  const funcAlpha = mk({
+    type: "function_declaration",
+    line: 1,
+    endLine: 1,
+    fields: { name: idNode("alpha"), parameters: paramsNode() },
+    namedChildren: [alphaBody],
+  });
+  const funcHelper = mk({
+    type: "function_declaration",
+    line: 2,
+    endLine: 2,
+    fields: { name: idNode("helper"), parameters: paramsNode() },
+  });
+  const renderBody = mk({ type: "statement_block", line: 4, namedChildren: [callTo("alpha", 4)] });
+  const methodRender = mk({
+    type: "method_definition",
+    line: 4,
+    endLine: 4,
+    fields: { name: idNode("render"), parameters: paramsNode() },
+    namedChildren: [renderBody],
+  });
+  const classBody = mk({ type: "class_body", line: 3, endLine: 5, namedChildren: [methodRender] });
+  const classWidget = mk({
+    type: "class_declaration",
+    line: 3,
+    endLine: 5,
+    fields: { name: idNode("Widget") },
+    namedChildren: [classBody],
+  });
+  const interfaceShape = mk({
+    type: "interface_declaration",
+    line: 6,
+    endLine: 6,
+    fields: { name: idNode("Shape") },
+  });
+  return mk({
+    type: "program",
+    line: 1,
+    endLine: 6,
+    namedChildren: [funcAlpha, funcHelper, classWidget, interfaceShape],
+  });
+}
+
+async function loadJsonl<T>(file: string): Promise<T[]> {
+  const content = await readFile(file, "utf8");
+  return content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as T);
+}
+
+function prf(produced: Set<string>, expected: Set<string>): { precision: number; recall: number } {
+  let truePos = 0;
+  for (const item of produced) {
+    if (expected.has(item)) {
+      truePos += 1;
+    }
+  }
+  return {
+    precision: produced.size === 0 ? 0 : truePos / produced.size,
+    recall: expected.size === 0 ? 0 : truePos / expected.size,
+  };
+}
+
+test("AC1.2/AC1.3 — extracted symbols/calls hit precision ≥ 0.90 and recall ≥ 0.85", async () => {
+  const layer = extractSymbolLayer(buildWidgetTree(), "src/widget.ts", "typescript");
+  const expectedSymbols = await loadJsonl<SymbolNode>(path.join(FIXTURE_DIR, "expected", "symbols.jsonl"));
+  const expectedCalls = await loadJsonl<CallEdge>(path.join(FIXTURE_DIR, "expected", "calls.jsonl"));
+
+  const symbolKey = (s: SymbolNode) => `${s.id}|${s.kind}|${s.startLine}`;
+  const callKey = (c: CallEdge) => `${c.kind}|${c.from}|${c.to}`;
+
+  const symbolPrf = prf(new Set(layer.symbols.map(symbolKey)), new Set(expectedSymbols.map(symbolKey)));
+  const callPrf = prf(new Set(layer.calls.map(callKey)), new Set(expectedCalls.map(callKey)));
+
+  expect(symbolPrf.precision).toBeGreaterThanOrEqual(0.9);
+  expect(symbolPrf.recall).toBeGreaterThanOrEqual(0.85);
+  expect(callPrf.precision).toBeGreaterThanOrEqual(0.9);
+  expect(callPrf.recall).toBeGreaterThanOrEqual(0.85);
+});
+
+test("AC1.1 — emits function/class/method/interface nodes + calls/defines/unresolved edges", () => {
+  const layer = extractSymbolLayer(buildWidgetTree(), "src/widget.ts", "typescript");
+  const kinds = new Set(layer.symbols.map((symbol) => symbol.kind));
+  expect(kinds).toEqual(new Set(["function", "class", "method", "interface"]));
+  const callKinds = new Set(layer.calls.map((call) => call.kind));
+  expect(callKinds.has("defines")).toBe(true);
+  expect(callKinds.has("calls")).toBe(true);
+});
+
+test("AC1.4 — symbol ids are stable + content-independent; re-run is byte-identical", () => {
+  const a = extractSymbolLayer(buildWidgetTree(), "src/widget.ts", "typescript");
+  const b = extractSymbolLayer(buildWidgetTree(), "src/widget.ts", "typescript");
+  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+  expect(a.symbols.map((symbol) => symbol.id)).toEqual([
+    "src/widget.ts#alpha",
+    "src/widget.ts#helper",
+    "src/widget.ts#Widget",
+    "src/widget.ts#Widget.render",
+    "src/widget.ts#Shape",
+  ]);
+});
+
+test("AC1.4 — colliding names get a positional @startLine disambiguator only", () => {
+  const idNodeLocal = (text: string): TsNode => mk({ type: "identifier", text });
+  const dup1 = mk({
+    type: "function_declaration",
+    line: 1,
+    endLine: 1,
+    fields: { name: idNodeLocal("dup"), parameters: paramsNode() },
+  });
+  const dup2 = mk({
+    type: "function_declaration",
+    line: 5,
+    endLine: 5,
+    fields: { name: idNodeLocal("dup"), parameters: paramsNode() },
+  });
+  const unique = mk({
+    type: "function_declaration",
+    line: 9,
+    endLine: 9,
+    fields: { name: idNodeLocal("only"), parameters: paramsNode() },
+  });
+  const root = mk({ type: "program", line: 1, endLine: 9, namedChildren: [dup1, dup2, unique] });
+  const layer = extractSymbolLayer(root, "src/dup.ts", "typescript");
+  const ids = layer.symbols.map((symbol) => symbol.id);
+  expect(ids).toEqual(["src/dup.ts#dup@1", "src/dup.ts#dup@5", "src/dup.ts#only"]);
+});
+
+test("unresolved calls to unknown callees are kept as unresolved-call edges", () => {
+  const idNodeLocal = (text: string): TsNode => mk({ type: "identifier", text });
+  const body = mk({
+    type: "statement_block",
+    line: 1,
+    namedChildren: [
+      mk({ type: "call_expression", line: 1, fields: { function: idNodeLocal("externalThing") }, text: "externalThing()" }),
+    ],
+  });
+  const fn = mk({
+    type: "function_declaration",
+    line: 1,
+    endLine: 2,
+    fields: { name: idNodeLocal("main"), parameters: paramsNode() },
+    namedChildren: [body],
+  });
+  const root = mk({ type: "program", line: 1, endLine: 2, namedChildren: [fn] });
+  const layer = extractSymbolLayer(root, "src/main.ts", "typescript");
+  const unresolved = layer.calls.filter((call) => call.kind === "unresolved-call");
+  expect(unresolved).toHaveLength(1);
+  expect(unresolved[0]?.to).toBe("externalThing");
+  expect(unresolved[0]?.resolved).toBe(false);
+});
+
+test("Java class and method extraction", () => {
+  const idNode = (text: string): TsNode => mk({ type: "identifier", text });
+  const methodBody = mk({ type: "block", line: 4, namedChildren: [
+    mk({ type: "method_invocation", line: 4, fields: { method: idNode("helper") }, text: "helper()" }),
+  ]});
+  const methodHelper = mk({
+    type: "method_declaration",
+    line: 3,
+    endLine: 3,
+    fields: { name: idNode("helper"), parameters: mk({ type: "formal_parameters", text: "()" }) },
+  });
+  const methodMain = mk({
+    type: "method_declaration",
+    line: 4,
+    endLine: 5,
+    fields: { name: idNode("main"), parameters: mk({ type: "formal_parameters", text: "()" }) },
+    namedChildren: [methodBody],
+  });
+  const classBody = mk({ type: "class_body", line: 2, endLine: 6, namedChildren: [methodHelper, methodMain] });
+  const classApp = mk({
+    type: "class_declaration",
+    line: 1,
+    endLine: 6,
+    fields: { name: idNode("App") },
+    namedChildren: [classBody],
+  });
+  const root = mk({ type: "program", line: 1, endLine: 6, namedChildren: [classApp] });
+  const layer = extractSymbolLayer(root, "src/App.java", "java");
+
+  expect(layer.symbols).toHaveLength(3); // App class + 2 methods
+  const classSymbol = layer.symbols.find((s) => s.name === "App");
+  expect(classSymbol).toBeDefined();
+  expect(classSymbol?.kind).toBe("class");
+
+  const methods = layer.symbols.filter((s) => s.kind === "method");
+  expect(methods).toHaveLength(2);
+});
+
+test("Python function and class extraction", () => {
+  const idNode = (text: string): TsNode => mk({ type: "identifier", text });
+  const funcBody = mk({ type: "block", line: 4, namedChildren: [
+    mk({ type: "call", line: 4, fields: { function: idNode("helper") }, text: "helper()" }),
+  ]});
+  const funcHelper = mk({
+    type: "function_definition",
+    line: 2,
+    endLine: 2,
+    fields: { name: idNode("helper"), parameters: mk({ type: "parameters", text: "()" }) },
+  });
+  const funcMain = mk({
+    type: "function_definition",
+    line: 4,
+    endLine: 5,
+    fields: { name: idNode("main"), parameters: mk({ type: "parameters", text: "()" }) },
+    namedChildren: [funcBody],
+  });
+  const methodProcess = mk({
+    type: "function_definition",
+    line: 8,
+    endLine: 8,
+    fields: { name: idNode("process"), parameters: mk({ type: "parameters", text: "(self)" }) },
+  });
+  const classBody = mk({ type: "block", line: 7, endLine: 9, namedChildren: [methodProcess] });
+  const classApp = mk({
+    type: "class_definition",
+    line: 6,
+    endLine: 9,
+    fields: { name: idNode("App") },
+    namedChildren: [classBody],
+  });
+  const root = mk({ type: "program", line: 1, endLine: 9, namedChildren: [funcHelper, funcMain, classApp] });
+  const layer = extractSymbolLayer(root, "src/main.py", "python");
+
+  expect(layer.symbols).toHaveLength(4); // 2 functions + 1 class + 1 nested function (process)
+  const classSymbol = layer.symbols.find((s) => s.name === "App");
+  expect(classSymbol).toBeDefined();
+  expect(classSymbol?.kind).toBe("class");
+
+  const functions = layer.symbols.filter((s) => s.kind === "function");
+  expect(functions.length).toBeGreaterThan(0); // Should have at least the top-level functions
+});

package/src/gdgraph/treesitter/extract.ts

@@ -0,0 +1,389 @@
+// Tree-sitter symbol/call extraction (specification.md §8.1, §9; T-B12).
+//
+// PURE structural walk over a parsed tree, producing a sorted, stable
+// `SymbolLayer`. This module NEVER imports `web-tree-sitter` (C0-2/C0-14) — the
+// adapter parses and passes the root node through the minimal `TsNode` shape
+// below, so extraction is dependency-free and unit-testable with a plain mock
+// tree. Determinism: symbols sorted by (path, startLine, name); calls sorted by
+// (from, to, kind); ids are content-independent positional
+// (`<path>#<Container>.<name>`, `@<startLine>` only on name collision).
+
+import type { CallEdge, SymbolKind, SymbolLayer, SymbolNode } from "../types";
+
+// The minimal syntax-node contract the walk needs. `web-tree-sitter`'s SyntaxNode
+// is structurally compatible; a test can supply a hand-built mock.
+export interface TsNode {
+  type: string;
+  text: string;
+  startPosition: { row: number; column: number };
+  endPosition: { row: number; column: number };
+  childForFieldName(field: string): TsNode | null;
+  readonly namedChildren: TsNode[];
+  readonly children: TsNode[];
+}
+
+type Language = "typescript" | "javascript" | "java" | "python";
+
+const FUNCTION_TYPES = new Set([
+  // TypeScript/JavaScript
+  "function_declaration", "function_signature", "generator_function_declaration",
+  // Python
+  "function_definition",
+]);
+const METHOD_TYPES = new Set([
+  // TypeScript/JavaScript
+  "method_definition", "method_signature",
+  // Java
+  "method_declaration",
+]);
+const CLASS_TYPES = new Set([
+  // TypeScript/JavaScript
+  "class_declaration", "class",
+  // Java
+  "class_declaration",
+  // Python
+  "class_definition",
+]);
+const INTERFACE_TYPES = new Set([
+  // TypeScript/JavaScript
+  "interface_declaration",
+  // Java
+  "interface_declaration",
+]);
+const CALL_TYPES = new Set([
+  // TypeScript/JavaScript
+  "call_expression", "new_expression",
+  // Java
+  "method_invocation",
+  // Python
+  "call",
+]);
+const ARROW_HOLDER_TYPES = new Set([
+  // TypeScript/JavaScript
+  "lexical_declaration", "variable_declaration",
+]);
+
+interface RawSymbol {
+  base: string;
+  node: SymbolNode;
+}
+
+// Extract the symbol layer from a parsed tree root. `filePath` is the owning
+// file path (matches a file GraphNode.path).
+export function extractSymbolLayer(root: TsNode, filePath: string, language: Language): SymbolLayer {
+  const raw: RawSymbol[] = [];
+  const calls: CallEdge[] = [];
+
+  // Walk the tree, tracking the enclosing class/interface container + the
+  // nearest enclosing symbol id (for call attribution).
+  const visit = (node: TsNode, container: string | null, enclosingSymbolId: string | null): void => {
+    let nextContainer = container;
+    let nextEnclosing = enclosingSymbolId;
+
+    const symbol = symbolFromNode(node, filePath, container, language);
+    if (symbol) {
+      raw.push(symbol);
+      nextEnclosing = symbol.node.id;
+      if (symbol.node.kind === "class" || symbol.node.kind === "interface") {
+        nextContainer = symbol.node.name;
+      }
+    } else if (ARROW_HOLDER_TYPES.has(node.type)) {
+      // `const foo = () => {}` / `const Bar = function () {}` — arrow/const fns.
+      for (const declared of arrowFunctionSymbols(node, filePath, container, language)) {
+        raw.push(declared);
+        // Descend into the arrow body under this symbol's id below.
+      }
+    }
+
+    if (CALL_TYPES.has(node.type)) {
+      const call = callFromNode(node, filePath, enclosingSymbolId);
+      if (call) {
+        calls.push(call);
+      }
+    }
+
+    for (const child of node.namedChildren) {
+      visit(child, nextContainer, nextEnclosing);
+    }
+  };
+
+  visit(root, null, null);
+
+  // Disambiguate id collisions with a positional `@<startLine>` suffix.
+  const baseCounts = new Map<string, number>();
+  for (const entry of raw) {
+    baseCounts.set(entry.base, (baseCounts.get(entry.base) ?? 0) + 1);
+  }
+  const symbolNodes: SymbolNode[] = raw.map((entry) => {
+    if ((baseCounts.get(entry.base) ?? 0) > 1) {
+      return { ...entry.node, id: `${entry.base}@${entry.node.startLine}` };
+    }
+    return entry.node;
+  });
+
+  // `defines` edges: file → each symbol (containment).
+  const defines: CallEdge[] = symbolNodes.map((symbol) => ({
+    id: `defines:${filePath}->${symbol.id}`,
+    from: filePath,
+    to: symbol.id,
+    kind: "defines",
+    resolved: true,
+  }));
+
+  // Resolve CALL targets to same-file symbols by name; else unresolved-call.
+  const nameToId = new Map<string, string>();
+  for (const symbol of symbolNodes) {
+    if (!nameToId.has(symbol.name)) {
+      nameToId.set(symbol.name, symbol.id);
+    }
+  }
+  const resolvedCalls: CallEdge[] = calls.map((call, index) => {
+    const calleeName = lastSegment(call.to);
+    const target = nameToId.get(calleeName);
+    if (target) {
+      return {
+        id: `call:${call.from}->${target}:${index}`,
+        from: call.from,
+        to: target,
+        kind: "calls",
+        resolved: true,
+      };
+    }
+    return {
+      id: `unresolved:${call.from}->${call.to}:${index}`,
+      from: call.from,
+      to: call.to,
+      kind: "unresolved-call",
+      resolved: false,
+    };
+  });
+
+  const sortedSymbols = symbolNodes.slice().sort(compareSymbols);
+  const sortedCalls = [...defines, ...resolvedCalls].sort(compareCalls);
+
+  // Reassign call ids after sort so they are stable + positional-free of index
+  // ordering surprises (ids derived from endpoints, not array position).
+  const stableCalls = sortedCalls.map((call) => ({
+    ...call,
+    id: `${call.kind}:${call.from}=>${call.to}`,
+  }));
+  // De-duplicate identical edges (same from/to/kind) produced by repeats.
+  const seen = new Set<string>();
+  const dedupedCalls: CallEdge[] = [];
+  for (const call of stableCalls) {
+    const key = `${call.kind}|${call.from}|${call.to}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    dedupedCalls.push(call);
+  }
+
+  return { symbols: sortedSymbols, calls: dedupedCalls };
+}
+
+// Cross-file call resolution (global pass). `extractSymbolLayer` runs per file,
+// so it can only resolve calls whose target is defined in the SAME file; every
+// cross-file call is left as `unresolved-call` — which made callers/impact
+// under-report badly (e.g. `TasksApi.runPipeline()` from another file). This
+// pass runs AFTER all files are aggregated: it upgrades an `unresolved-call` to
+// a resolved `calls` edge when the callee's last segment maps to EXACTLY ONE
+// symbol across the whole graph. Ambiguous names (collisions) are left
+// unresolved — never guess a wrong edge. Self-edges are dropped.
+export function resolveCrossFileCalls(symbols: SymbolNode[], calls: CallEdge[]): CallEdge[] {
+  const nameCount = new Map<string, number>();
+  const nameToId = new Map<string, string>();
+  for (const symbol of symbols) {
+    nameCount.set(symbol.name, (nameCount.get(symbol.name) ?? 0) + 1);
+    if (!nameToId.has(symbol.name)) {
+      nameToId.set(symbol.name, symbol.id);
+    }
+  }
+
+  const seen = new Set<string>();
+  const out: CallEdge[] = [];
+  for (const call of calls) {
+    let edge = call;
+    if (call.kind === "unresolved-call") {
+      const name = lastSegment(call.to);
+      const target = nameCount.get(name) === 1 ? nameToId.get(name) : undefined;
+      if (target && target !== call.from) {
+        edge = { id: `calls:${call.from}=>${target}`, from: call.from, to: target, kind: "calls", resolved: true };
+      }
+    }
+    const key = `${edge.kind}|${edge.from}|${edge.to}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(edge);
+  }
+  return out;
+}
+
+function symbolFromNode(
+  node: TsNode,
+  filePath: string,
+  container: string | null,
+  language: Language,
+): RawSymbol | null {
+  const kind = symbolKind(node.type);
+  if (!kind) {
+    return null;
+  }
+  const name = nameOf(node);
+  if (!name) {
+    return null;
+  }
+  return makeSymbol(node, filePath, container, language, kind, name);
+}
+
+function arrowFunctionSymbols(
+  node: TsNode,
+  filePath: string,
+  container: string | null,
+  language: Language,
+): RawSymbol[] {
+  const out: RawSymbol[] = [];
+  for (const declarator of node.namedChildren) {
+    if (declarator.type !== "variable_declarator") {
+      continue;
+    }
+    const value = declarator.childForFieldName("value");
+    if (!value) {
+      continue;
+    }
+    if (value.type === "arrow_function" || value.type === "function" || value.type === "function_expression") {
+      const nameNode = declarator.childForFieldName("name");
+      const name = nameNode?.text;
+      if (name) {
+        out.push(makeSymbol(declarator, filePath, container, language, "function", name));
+      }
+    }
+  }
+  return out;
+}
+
+function makeSymbol(
+  node: TsNode,
+  filePath: string,
+  container: string | null,
+  language: Language,
+  kind: SymbolKind,
+  name: string,
+): RawSymbol {
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const base = container ? `${filePath}#${container}.${name}` : `${filePath}#${name}`;
+  const symbol: SymbolNode = {
+    id: base,
+    kind,
+    path: filePath,
+    name,
+    container,
+    startLine,
+    endLine,
+    language,
+    signature: renderSignature(node, kind, container, name),
+  };
+  return { base, node: symbol };
+}
+
+function callFromNode(node: TsNode, filePath: string, enclosingSymbolId: string | null): CallEdge | null {
+  // Extract function/method reference from call expressions
+  const fn = node.childForFieldName("function")
+    ?? node.childForFieldName("constructor")
+    ?? node.childForFieldName("method"); // Java method_invocation
+
+  let calleeText: string;
+  if (fn?.text) {
+    calleeText = firstLine(fn.text);
+  } else if (node.text) {
+    // For Python and Java: fall back to extracting from full text
+    calleeText = firstLine(node.text);
+  } else {
+    return null;
+  }
+
+  if (!calleeText) {
+    return null;
+  }
+  return {
+    id: "pending",
+    from: enclosingSymbolId ?? filePath,
+    to: calleeText,
+    kind: "calls",
+    resolved: false,
+  };
+}
+
+function symbolKind(type: string): SymbolKind | null {
+  if (FUNCTION_TYPES.has(type)) {
+    return "function";
+  }
+  if (METHOD_TYPES.has(type)) {
+    return "method";
+  }
+  if (CLASS_TYPES.has(type)) {
+    return "class";
+  }
+  if (INTERFACE_TYPES.has(type)) {
+    return "interface";
+  }
+  return null;
+}
+
+function nameOf(node: TsNode): string | null {
+  const nameNode = node.childForFieldName("name");
+  if (nameNode && nameNode.text) {
+    return firstLine(nameNode.text);
+  }
+  return null;
+}
+
+function renderSignature(node: TsNode, kind: SymbolKind, container: string | null, name: string): string {
+  const params = node.childForFieldName("parameters");
+  const paramText = params ? firstLine(params.text) : "()";
+  const prefix = container ? `${container}.` : "";
+
+  switch (kind) {
+    case "class":
+      return `class ${name}`;
+    case "interface":
+      return `interface ${name}`;
+    case "method":
+      return `${prefix}${name}${paramText}`;
+    case "function":
+      return `${name}${paramText}`;
+    default:
+      return `${name}${paramText}`;
+  }
+}
+
+function lastSegment(callee: string): string {
+  const withoutCall = callee.replace(/\(.*$/s, "");
+  const parts = withoutCall.split(".");
+  return (parts[parts.length - 1] ?? withoutCall).trim();
+}
+
+function firstLine(text: string): string {
+  return text.split("\n")[0]?.trim() ?? "";
+}
+
+function compareSymbols(a: SymbolNode, b: SymbolNode): number {
+  if (a.path !== b.path) {
+    return a.path < b.path ? -1 : 1;
+  }
+  if (a.startLine !== b.startLine) {
+    return a.startLine - b.startLine;
+  }
+  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+
+function compareCalls(a: CallEdge, b: CallEdge): number {
+  if (a.from !== b.from) {
+    return a.from < b.from ? -1 : 1;
+  }
+  if (a.to !== b.to) {
+    return a.to < b.to ? -1 : 1;
+  }
+  return a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0;
+}