syntaxai/tdd.md · commit ddd862b

§5 graphDepth ported to Go + Rust; dive and ripgrep audits gain second measured metric

Each repo now has TWO measured §5 cells (workingSetFit + graphDepth)
instead of one. Module-granularity per language: TS = file (existing
metric); Go = package directory; Rust = crate. Documented as the
natural cross-language analog in the helper's source comment and in
each audit page's hand-trace.

Measured results (same SHAs as the workingSetFit run):
  dive @d6c69194:
    27 package directories, 80 internal edges, depth 12
    (originally hand-estimated ~5; the estimate folded subdirectories
    into top-level categories, missing the actual hop count)

  ripgrep @4519153e:
    10 workspace crates, 15 internal production-dep edges, depth 5
    (originally hand-estimated ~5; the measurement CONFIRMS the
    estimate exactly — same chain, same depth, same nodes)

Components:
- src/b32_graph_depth_polyglot.ts — pure Layer 1: takes {nodes,
  edges}, returns {nodeCount, edgeCount, depth}. Memoised DFS with
  bounded-cycle handling that mirrors b32_sama_v2_metrics.ts.
- src/c14_go_graph_depth.ts — Layer 2 Go adapter: reads go.mod for
  module path; walks .go files; parses import blocks; resolves
  intra-module imports to package directories; dedupes per-package.
- src/c14_rust_graph_depth.ts — Layer 2 Rust adapter: parses
  Cargo.toml workspace + root crate; identifies workspace-internal
  deps via path = "..." or workspace = true cross-referenced
  against [workspace.dependencies]; excludes dev-dependencies
  (not part of the runtime DAG). Scoped TOML subset parser handles
  [[bin]] / [[test]] array-of-tables correctly so root [package]
  name doesn't get clobbered by [[test]] name.
- scripts/measure-graph-depth.ts — CLI: --lang go|rust + repo-path
  → JSON with nodeCount, edgeCount, depth.
- 31 new tests cover: empty/single/chain/cycle/branching graphs for
  the pure helper; go.mod parsing + import-block parsing + the
  fixture chain for the Go adapter; Cargo.toml inline-table +
  workspace + virtual-workspace for the Rust adapter.

Hand-trace anchors:
- Ripgrep crate DAG enumerated explicitly in the audit (10 crates
  listed, 15 edges tabulated by source crate, longest chain
  identified as ripgrep → grep → grep-printer → grep-searcher →
  grep-matcher).
- Dive audit notes the 12 vs ~5 finding honestly: the estimate
  folded subdirectory hops into top-level categories.

Anti-fudge: src/b32_sama_v2_metrics.ts (the TS metric) unchanged.
No §4 verifier logic changed. /sama/v2/verify still reports 7/7 ✓
on this repo. Module-granularity asymmetry between TS/Go/Rust is
the same shape as the v2.1 dialects already drafted at /sama/v2 §6.A.

Co-Authored-By: Claude Opus 4.7 <[email protected]>

author: syntaxai <[email protected]>
date: 2026-05-24 11:15:57 +01:00
parent: 60056b1
commit: ddd862b1e2a436f9e4ba6e8d6609638a87e60f1b

9 files changed · +1089 −2

modified content/blog/sama-v2-go-project-dive.md +11 −1

@@ -146,7 +146,7 @@ Derives from Law. No file's declared layer is contradicted by what it imports.
146	146	\| metric \| `dive` (Go) \| WP plugin (PHP, estimated) \| tdd.md (TS, measured) \|
147	147	\|---\|---\|---\|---\|
148	148	\| §4 checks passing \| ~5 / 7 (estimated) \| 0 / 7 \| 7 / 7 \|
149		-\| graphDepth \| ~5 (estimated; cmd → command → ui → dive → filetree → internal/utils) \| ~3 \| 7 \|
	149	+\| graphDepth \| 12 (measured, [dive@d6c69194](https://github.com/wagoodman/dive/commit/d6c691947f8fda635c952a17ee3b7555379d58f0)) — originally estimated ~5 \| ~3 \| 7 \|
150	150	\| boundaryRatio \| ~85% (estimated; one borderline case in `options/ci.go`) \| <10% \| 100% \|
151	151	\| workingSetFit (50–500 LOC) \| 52.17% (measured, [dive@d6c69194](https://github.com/wagoodman/dive/commit/d6c691947f8fda635c952a17ee3b7555379d58f0)) — originally estimated ~80% \| ~47% \| 80% (measured) \|
152	152	\| violationCounts (sum) \| ~30 (estimated; mostly Modeled-tests gaps) \| 17+ \| 0 \|
@@ -159,6 +159,16 @@ The distribution explains it: 44 files under 50 LOC (mostly small type-only
159	159
160	160	The original ~80% estimate was wrong, and wrong in a direction casual eyeballing wouldn't catch — counting visible-on-the-screen files isn't the same as counting them and applying a band filter. That 28-point miss between estimate and measurement is itself the empirical case for the metric existing at all: the metric surfaces a property the human estimate missed.
161	161
	162	+### graphDepth, measured: 12 (originally estimated ~5)
	163	+
	164	+The polyglot graphDepth emitter at [`scripts/measure-graph-depth.ts`](/GIT/syntaxai/tdd.md/blob/main/scripts/measure-graph-depth.ts) walks `dive`'s [`go.mod`](https://github.com/wagoodman/dive/blob/d6c691947f8fda635c952a17ee3b7555379d58f0/go.mod), collects every `.go` file's imports, filters to intra-module imports (those starting with `github.com/wagoodman/dive/`), aggregates them per-package-directory, and computes the longest path. The result for `dive@d6c69194`: 27 package directories, 80 internal edges, longest dependency chain of depth 12.
	165	+
	166	+A 12-deep import chain is more than twice the audit's eyeball estimate of ~5. The estimate was wrong because I was thinking in top-level package categories (`cmd`, `command`, `ui`, `dive`, `filetree`, `internal/utils` — six things), but the actual Go package graph treats each subdirectory as its own package. `cmd/dive/cli/internal/ui/v1/viewmodel` is a different package from `cmd/dive/cli/internal/ui/v1/view`, even though they read like one category to a human; the import graph sees them as distinct hops. The 12-deep chain weaves through subdirectories the human-readable description folded into one bullet.
	167	+
	168	+This is the same shape of finding as the workingSetFit one above: the metric sees the structure; the eye sees the categories. Both are useful, but only the metric is mechanically comparable across repos.
	169	+
	170	+Module-granularity note: the polyglot graphDepth metric counts at the Go package-directory level — multiple `.go` files in one directory share their package and therefore their imports. This is the natural Go analog to the TS file-level metric (TS one module ≈ one file; Go one package ≈ one directory). The semantic is documented in [`src/b32_graph_depth_polyglot.ts`](/GIT/syntaxai/tdd.md/blob/main/src/b32_graph_depth_polyglot.ts).
	171	+
162	172	## What `dive` would look like at 7/7 — the last 30%
163	173
164	174	Far less work than the WordPress refactor sketch from earlier. Three concrete changes get from ~5/7 to 7/7:

modified content/blog/sama-v2-rust-project-ripgrep.md +28 −1

@@ -150,7 +150,7 @@ Derives from Law on the same edge set.
150	150	\| metric \| ripgrep \| dive (Go) \| tdd.md (TS, measured) \| WP plugin (PHP) \|
151	151	\|---\|---\|---\|---\|---\|
152	152	\| §4 checks passing \| ~3/7 strict, ~5/7 under v2.1 dialects (estimated) \| ~5/7 (estimated) \| 7/7 ✓ \| 0/7 \|
153		-\| graphDepth \| ~5 estimated (matcher → engine → searcher → printer → core) \| ~5 (estimated) \| 7 \| ~3 \|
	153	+\| graphDepth \| 5 (measured, [ripgrep@4519153e](https://github.com/BurntSushi/ripgrep/commit/4519153e5e461527f4bca45b042fff45c4ec6fb9)) — originally estimated ~5, confirmed exactly \| 12 (measured, [dive@d6c69194](https://github.com/wagoodman/dive/commit/d6c691947f8fda635c952a17ee3b7555379d58f0)) — originally estimated ~5 \| 7 \| ~3 \|
154	154	\| boundaryRatio \| ~95% (estimated) \| ~85% (estimated) \| 100% \| <10% \|
155	155	\| workingSetFit (50–500 LOC) \| 54.00% (measured, [ripgrep@4519153e](https://github.com/BurntSushi/ripgrep/commit/4519153e5e461527f4bca45b042fff45c4ec6fb9)) — originally estimated ~60% \| 52.17% (measured, [dive@d6c69194](https://github.com/wagoodman/dive/commit/d6c691947f8fda635c952a17ee3b7555379d58f0)) — originally estimated ~80% \| 80% \| ~47% \|
156	156	\| violationCounts (sum) \| ~50 estimated (Atomic + Modeled-tests under sibling-rule) \| ~30 (estimated) \| 0 \| 17+ \|
@@ -163,6 +163,33 @@ The cross-repo comparison the measurement makes possible is more interesting tha
163	163
164	164	This is exactly the §5 intent. The metric surfaces a property; whether that property is good or bad depends on what the file content should be. Compliance scores conflate the two; metrics keep them separate.
165	165
	166	+### graphDepth, measured: 5 (originally estimated ~5 — confirmed exactly)
	167	+
	168	+The polyglot graphDepth emitter at [`scripts/measure-graph-depth.ts`](/GIT/syntaxai/tdd.md/blob/main/scripts/measure-graph-depth.ts) reads `ripgrep`'s root [`Cargo.toml`](https://github.com/BurntSushi/ripgrep/blob/4519153e5e461527f4bca45b042fff45c4ec6fb9/Cargo.toml), identifies workspace members + the root crate, parses each member's `[dependencies]` section (production deps only — `[dev-dependencies]` excluded from the runtime DAG), filters to workspace-internal deps (`path = "../foo"` or `workspace = true` cross-referenced against `[workspace.dependencies]`), and computes the longest crate-level chain. The result for `ripgrep@4519153e`: 10 workspace crates, 15 internal edges, longest dependency chain of depth 5.
	169	+
	170	+Hand-trace (auditable per [/sama/v2 §0](/sama/v2)). The 10 workspace crates and their internal edges, extracted from `crates/*/Cargo.toml`:
	171	+
	172	+\| crate \| internal deps \|
	173	+\|---\|---\|
	174	+\| `ripgrep` (root, binary `rg`) \| `grep`, `ignore` \|
	175	+\| `grep` (meta-crate) \| `grep-cli`, `grep-matcher`, `grep-pcre2`, `grep-printer`, `grep-regex`, `grep-searcher` \|
	176	+\| `grep-cli` \| `globset` \|
	177	+\| `grep-matcher` \| (none — pure trait crate, the abstraction at the bottom) \|
	178	+\| `grep-pcre2` \| `grep-matcher` \|
	179	+\| `grep-regex` \| `grep-matcher` \|
	180	+\| `grep-searcher` \| `grep-matcher` \|
	181	+\| `grep-printer` \| `grep-matcher`, `grep-searcher` \|
	182	+\| `ignore` \| `globset` \|
	183	+\| `globset` \| (none — leaf crate) \|
	184	+
	185	+15 edges total (count: 2 + 6 + 1 + 0 + 1 + 1 + 1 + 2 + 1 + 0 = 15 ✓).
	186	+
	187	+The longest path: `ripgrep → grep → grep-printer → grep-searcher → grep-matcher` — five crates, depth 5. Multiple paths reach depth 5 (e.g. `ripgrep → grep → grep-pcre2 → grep-matcher` is only depth 4; `ripgrep → grep → grep-searcher → grep-matcher` is depth 4; the printer-via-searcher chain is what wins). The audit's original estimate "(matcher → engine → searcher → printer → core)" turns out to describe the same chain reading bottom-up: `matcher ← searcher ← printer ← grep ← ripgrep`. Same five nodes, same depth, confirmed by measurement.
	188	+
	189	+Module-granularity note: the polyglot graphDepth metric counts at the Rust crate level — each Cargo workspace member is one node. This is the natural Rust analog to the TS file-level metric (TS one module ≈ one file; Rust one module ≈ one crate). Semantic documented in [`src/b32_graph_depth_polyglot.ts`](/GIT/syntaxai/tdd.md/blob/main/src/b32_graph_depth_polyglot.ts).
	190	+
	191	+The contrast with `dive`'s measured depth 12 is itself interesting: ripgrep's crate-level graph is flatter than dive's package-directory graph, even though both are mature CLI codebases. Some of that is genuine — ripgrep's workspace is 10 crates organized as a clean DAG; dive's 27 package directories include many subdirectory hops that drive the chain longer. Some is granularity: a Rust crate often contains what a Go developer would split into multiple package directories. The two depths aren't directly comparable for "which codebase is deeper"; they ARE directly comparable as "graphDepth at each language's natural module unit," which is the spec's intent.
	192	+
166	193	## What a rebuilt ripgrep would look like — the small version
167	194
168	195	For the full parallel-architecture sketch — every layer, every file move, predicted §5 metrics, the rebuilt `sama.profile.toml`, and concrete Rust code samples for the two file splits — see the companion post: [`ripgrep`, rebuilt under SAMA v2](/blog/sama-v2-rust-project-ripgrep-rebuilt).

added scripts/measure-graph-depth.ts +63 −0

@@ -0,0 +1,63 @@
	1	+#!/usr/bin/env bun
	2	+// measure-graph-depth — CLI for the §5 polyglot graphDepth metric.
	3	+// Given a path to a checked-out Go module or Rust Cargo workspace,
	4	+// emit the measured longest dependency chain as JSON to stdout.
	5	+//
	6	+// Usage:
	7	+// bun scripts/measure-graph-depth.ts <repo-path> --lang go
	8	+// bun scripts/measure-graph-depth.ts <repo-path> --lang rust
	9	+//
	10	+// Module-granularity per language: Go = package directory (multiple
	11	+// .go files in one directory share imports); Rust = crate (Cargo
	12	+// workspace member). See /sama/v2 §5 (operational) and the source
	13	+// comment at the top of src/b32_graph_depth_polyglot.ts.
	14	+
	15	+import { computeGoGraphDepth } from "../src/c14_go_graph_depth.ts";
	16	+import { computeRustGraphDepth } from "../src/c14_rust_graph_depth.ts";
	17	+
	18	+const args = process.argv.slice(2);
	19	+
	20	+const usage = (): never => {
	21	+ console.error(
	22	+ "Usage: bun scripts/measure-graph-depth.ts <repo-path> --lang go\|rust",
	23	+ );
	24	+ process.exit(2);
	25	+};
	26	+
	27	+if (args.length < 3) usage();
	28	+
	29	+const repoPath = args[0]!;
	30	+let lang: "go" \| "rust" \| null = null;
	31	+
	32	+for (let i = 1; i < args.length; i++) {
	33	+ const a = args[i];
	34	+ if (a === "--lang") {
	35	+ const v = args[++i];
	36	+ if (v !== "go" && v !== "rust") {
	37	+ console.error(`--lang must be "go" or "rust", got: ${v}`);
	38	+ process.exit(2);
	39	+ }
	40	+ lang = v;
	41	+ } else {
	42	+ console.error(`unknown argument: ${a}`);
	43	+ usage();
	44	+ }
	45	+}
	46	+
	47	+if (lang === null) usage();
	48	+
	49	+const result =
	50	+ lang === "go" ? computeGoGraphDepth(repoPath) : computeRustGraphDepth(repoPath);
	51	+
	52	+const output: Record<string, unknown> = {
	53	+ language: result.language,
	54	+ repoPath,
	55	+ ...(lang === "go"
	56	+ ? { modulePath: (result as { modulePath: string }).modulePath }
	57	+ : { workspaceName: (result as { workspaceName: string }).workspaceName }),
	58	+ nodeCount: result.nodeCount,
	59	+ edgeCount: result.edgeCount,
	60	+ depth: result.depth,
	61	+};
	62	+
	63	+console.log(JSON.stringify(output, null, 2));

added src/b32_graph_depth_polyglot.test.ts +137 −0

@@ -0,0 +1,137 @@
	1	+import { describe, expect, test } from "bun:test";
	2	+import { computeGraphDepth, type Graph } from "./b32_graph_depth_polyglot.ts";
	3	+
	4	+// Mirror b32_sama_v2_metrics.test.ts graphDepth cases. Same algorithm
	5	+// (longest path in import DAG with bounded cycles), same edge-cases
	6	+// (empty, single node, linear chain, cycle, branching). The polyglot
	7	+// helper is allowed to be language-agnostic but the formula and
	8	+// cycle-handling must match the TS reference.
	9	+
	10	+describe("computeGraphDepth — empty + trivial", () => {
	11	+ test("empty graph → 0 (matches TS metric on an empty file map)", () => {
	12	+ const r = computeGraphDepth({ nodes: [], edges: [] });
	13	+ expect(r.depth).toBe(0);
	14	+ expect(r.nodeCount).toBe(0);
	15	+ expect(r.edgeCount).toBe(0);
	16	+ });
	17	+
	18	+ test("single node, no edges → 1", () => {
	19	+ const r = computeGraphDepth({ nodes: ["a"], edges: [] });
	20	+ expect(r.depth).toBe(1);
	21	+ expect(r.nodeCount).toBe(1);
	22	+ expect(r.edgeCount).toBe(0);
	23	+ });
	24	+});
	25	+
	26	+describe("computeGraphDepth — linear chains", () => {
	27	+ test("chain a → b → c → 3", () => {
	28	+ const r = computeGraphDepth({
	29	+ nodes: ["a", "b", "c"],
	30	+ edges: [["a", "b"], ["b", "c"]],
	31	+ });
	32	+ expect(r.depth).toBe(3);
	33	+ expect(r.edgeCount).toBe(2);
	34	+ });
	35	+
	36	+ test("chain of 5 → 5 (matches the TS chain p3 → p2 → p1 → p0 case)", () => {
	37	+ const r = computeGraphDepth({
	38	+ nodes: ["a", "b", "c", "d", "e"],
	39	+ edges: [["a", "b"], ["b", "c"], ["c", "d"], ["d", "e"]],
	40	+ });
	41	+ expect(r.depth).toBe(5);
	42	+ });
	43	+});
	44	+
	45	+describe("computeGraphDepth — cycles are bounded", () => {
	46	+ test("cycle of 2 (a → b → a) terminates with finite depth", () => {
	47	+ const r = computeGraphDepth({
	48	+ nodes: ["a", "b"],
	49	+ edges: [["a", "b"], ["b", "a"]],
	50	+ });
	51	+ expect(Number.isFinite(r.depth)).toBe(true);
	52	+ expect(r.depth).toBeGreaterThanOrEqual(1);
	53	+ });
	54	+
	55	+ test("cycle of 3 (a → b → c → a) terminates with finite depth", () => {
	56	+ const r = computeGraphDepth({
	57	+ nodes: ["a", "b", "c"],
	58	+ edges: [["a", "b"], ["b", "c"], ["c", "a"]],
	59	+ });
	60	+ expect(Number.isFinite(r.depth)).toBe(true);
	61	+ expect(r.depth).toBeGreaterThanOrEqual(1);
	62	+ });
	63	+
	64	+ test("self-loop is also bounded", () => {
	65	+ const r = computeGraphDepth({
	66	+ nodes: ["a"],
	67	+ edges: [["a", "a"]],
	68	+ });
	69	+ expect(Number.isFinite(r.depth)).toBe(true);
	70	+ });
	71	+});
	72	+
	73	+describe("computeGraphDepth — branching → longest path, not sum", () => {
	74	+ test("a → {b, c} → d (diamond) → 3 (not 4)", () => {
	75	+ const r = computeGraphDepth({
	76	+ nodes: ["a", "b", "c", "d"],
	77	+ edges: [["a", "b"], ["a", "c"], ["b", "d"], ["c", "d"]],
	78	+ });
	79	+ expect(r.depth).toBe(3);
	80	+ });
	81	+
	82	+ test("two disjoint chains; longest wins", () => {
	83	+ const r = computeGraphDepth({
	84	+ nodes: ["a", "b", "x", "y", "z"],
	85	+ edges: [["a", "b"], ["x", "y"], ["y", "z"]],
	86	+ });
	87	+ // chain a→b has length 2; chain x→y→z has length 3.
	88	+ expect(r.depth).toBe(3);
	89	+ });
	90	+
	91	+ test("two paths different lengths, max picks the longer", () => {
	92	+ // a → b → c → d (4) and a → e (2). Longest path = 4.
	93	+ const r = computeGraphDepth({
	94	+ nodes: ["a", "b", "c", "d", "e"],
	95	+ edges: [["a", "b"], ["b", "c"], ["c", "d"], ["a", "e"]],
	96	+ });
	97	+ expect(r.depth).toBe(4);
	98	+ });
	99	+});
	100	+
	101	+describe("computeGraphDepth — edge filtering", () => {
	102	+ test("edges referencing non-declared nodes are silently ignored", () => {
	103	+ const r = computeGraphDepth({
	104	+ nodes: ["a", "b"],
	105	+ edges: [["a", "b"], ["a", "external"], ["external", "a"]],
	106	+ });
	107	+ // Only the a → b edge is between declared nodes. Depth = 2.
	108	+ expect(r.depth).toBe(2);
	109	+ expect(r.edgeCount).toBe(1);
	110	+ });
	111	+});
	112	+
	113	+describe("computeGraphDepth — reproducibility", () => {
	114	+ test("same input → identical output across two runs (deep-equal)", () => {
	115	+ const g: Graph = {
	116	+ nodes: ["a", "b", "c", "d"],
	117	+ edges: [["a", "b"], ["b", "c"], ["c", "d"]],
	118	+ };
	119	+ const r1 = computeGraphDepth(g);
	120	+ const r2 = computeGraphDepth(g);
	121	+ expect(r1).toEqual(r2);
	122	+ });
	123	+
	124	+ test("edge order independence — same edges in different order → same depth", () => {
	125	+ const r1 = computeGraphDepth({
	126	+ nodes: ["a", "b", "c"],
	127	+ edges: [["a", "b"], ["b", "c"]],
	128	+ });
	129	+ const r2 = computeGraphDepth({
	130	+ nodes: ["c", "a", "b"],
	131	+ edges: [["b", "c"], ["a", "b"]],
	132	+ });
	133	+ expect(r1.depth).toBe(r2.depth);
	134	+ expect(r1.nodeCount).toBe(r2.nodeCount);
	135	+ expect(r1.edgeCount).toBe(r2.edgeCount);
	136	+ });
	137	+});

added src/b32_graph_depth_polyglot.ts +89 −0

@@ -0,0 +1,89 @@
	1	+// b32 — logic: §5 graphDepth metric for polyglot dependency graphs.
	2	+// Pure function, no I/O. Given a directed graph as nodes + edges,
	3	+// returns the longest path length using memoised DFS. Cycles are
	4	+// bounded (back-edge target treated as terminal of depth 1) so the
	5	+// function always terminates with a finite number, mirroring
	6	+// b32_sama_v2_metrics.ts's computeGraphDepth.
	7	+//
	8	+// Module-granularity note (per /sama/v2 §5 operational and the v2.1
	9	+// dialects at /sama/v2#6a-v21-dialects-provisional): the TS metric
	10	+// works at FILE level because in TS one module ≈ one file. The
	11	+// natural cross-language analog is per-language: Go's unit is the
	12	+// PACKAGE DIRECTORY (multiple .go files in one directory all live in
	13	+// the same package and share imports); Rust's unit is the CRATE
	14	+// (Cargo workspace member). The depth measured here is the longest
	15	+// chain of dependency relationships at each language's natural unit.
	16	+// This semantic is documented in the adapter source comments
	17	+// (c14_go_graph_depth.ts, c14_rust_graph_depth.ts) and surfaced in
	18	+// the audit page hand-traces.
	19	+//
	20	+// Consumed by the two adapters which feed it a pre-built {nodes,
	21	+// edges} pair, keeping this module pure and unit-testable.
	22	+
	23	+export interface Graph {
	24	+ // List of node identifiers (deduplicated by the adapter before
	25	+ // calling). For Go: package-directory repo-relative paths. For
	26	+ // Rust: workspace-crate names. The helper does not care which.
	27	+ nodes: ReadonlyArray<string>;
	28	+ // Directed edges as [from, to]. The helper is forgiving: edges
	29	+ // referencing nodes not in `nodes` are silently ignored (they
	30	+ // can't extend a path through nodes the caller did not declare).
	31	+ edges: ReadonlyArray<readonly [string, string]>;
	32	+}
	33	+
	34	+export interface GraphDepthResult {
	35	+ nodeCount: number;
	36	+ edgeCount: number;
	37	+ depth: number;
	38	+}
	39	+
	40	+export const computeGraphDepth = (graph: Graph): GraphDepthResult => {
	41	+ const nodeSet = new Set(graph.nodes);
	42	+ if (nodeSet.size === 0) {
	43	+ return { nodeCount: 0, edgeCount: 0, depth: 0 };
	44	+ }
	45	+
	46	+ // Adjacency (only edges that connect declared nodes).
	47	+ const adj = new Map<string, string[]>();
	48	+ for (const n of nodeSet) adj.set(n, []);
	49	+ let edgeCount = 0;
	50	+ for (const [from, to] of graph.edges) {
	51	+ if (!nodeSet.has(from) \|\| !nodeSet.has(to)) continue;
	52	+ adj.get(from)!.push(to);
	53	+ edgeCount++;
	54	+ }
	55	+
	56	+ // Memoised DFS for longest path. Cycle handling matches
	57	+ // b32_sama_v2_metrics.ts: a re-entered node returns depth 1 so the
	58	+ // recursion terminates with a finite value (the Law check would
	59	+ // flag a cycle separately; the metric still has to emit a number).
	60	+ const memo = new Map<string, number>();
	61	+ const visiting = new Set<string>();
	62	+
	63	+ const depthFrom = (node: string): number => {
	64	+ const cached = memo.get(node);
	65	+ if (cached !== undefined) return cached;
	66	+ if (visiting.has(node)) return 1;
	67	+ visiting.add(node);
	68	+ let best = 1;
	69	+ for (const next of adj.get(node) ?? []) {
	70	+ const d = depthFrom(next) + 1;
	71	+ if (d > best) best = d;
	72	+ }
	73	+ visiting.delete(node);
	74	+ memo.set(node, best);
	75	+ return best;
	76	+ };
	77	+
	78	+ let max = 0;
	79	+ for (const n of nodeSet) {
	80	+ const d = depthFrom(n);
	81	+ if (d > max) max = d;
	82	+ }
	83	+
	84	+ return {
	85	+ nodeCount: nodeSet.size,
	86	+ edgeCount,
	87	+ depth: max,
	88	+ };
	89	+};

added src/c14_go_graph_depth.test.ts +172 −0

@@ -0,0 +1,172 @@
	1	+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
	2	+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
	3	+import { tmpdir } from "node:os";
	4	+import { resolve } from "node:path";
	5	+import {
	6	+ collectGoImports,
	7	+ computeGoGraphDepth,
	8	+ parseGoModulePath,
	9	+} from "./c14_go_graph_depth.ts";
	10	+
	11	+const FIXTURE = mkdtempSync(resolve(tmpdir(), "tdd-md-go-graph-"));
	12	+
	13	+const writeFile = (rel: string, content: string): void => {
	14	+ const abs = resolve(FIXTURE, rel);
	15	+ mkdirSync(abs.split("/").slice(0, -1).join("/"), { recursive: true });
	16	+ writeFileSync(abs, content);
	17	+};
	18	+
	19	+beforeAll(() => {
	20	+ writeFile(
	21	+ "go.mod",
	22	+ `module github.com/example/fixture
	23	+
	24	+go 1.22
	25	+`,
	26	+ );
	27	+ // Three packages forming a chain entry → middle → leaf, plus
	28	+ // some external imports we should NOT count.
	29	+ writeFile(
	30	+ "cmd/entry/main.go",
	31	+ `package main
	32	+
	33	+import (
	34	+ "fmt"
	35	+ "github.com/example/fixture/internal/middle"
	36	+ "github.com/example/external/library"
	37	+)
	38	+
	39	+func main() {
	40	+ fmt.Println(middle.X)
	41	+ _ = library.Y
	42	+}
	43	+`,
	44	+ );
	45	+ writeFile(
	46	+ "internal/middle/middle.go",
	47	+ `package middle
	48	+
	49	+import (
	50	+ "github.com/example/fixture/internal/leaf"
	51	+)
	52	+
	53	+var X = leaf.Z
	54	+`,
	55	+ );
	56	+ writeFile(
	57	+ "internal/leaf/leaf.go",
	58	+ `package leaf
	59	+
	60	+var Z = 1
	61	+`,
	62	+ );
	63	+ // A test file that should be excluded.
	64	+ writeFile(
	65	+ "internal/leaf/leaf_test.go",
	66	+ `package leaf
	67	+
	68	+import (
	69	+ "testing"
	70	+ "github.com/example/fixture/internal/middle"
	71	+)
	72	+
	73	+func TestZ(t *testing.T) { _ = middle.X }
	74	+`,
	75	+ );
	76	+ // A vendored file that should also be skipped.
	77	+ writeFile(
	78	+ "vendor/some/lib.go",
	79	+ `package some
	80	+
	81	+import "github.com/example/fixture/cmd/entry"
	82	+
	83	+var _ = entry.X
	84	+`,
	85	+ );
	86	+});
	87	+
	88	+afterAll(() => {
	89	+ rmSync(FIXTURE, { recursive: true, force: true });
	90	+});
	91	+
	92	+describe("parseGoModulePath", () => {
	93	+ test("extracts the module path from a typical go.mod", () => {
	94	+ expect(parseGoModulePath('module github.com/x/y\n\ngo 1.22\n'))
	95	+ .toBe('github.com/x/y');
	96	+ });
	97	+
	98	+ test("handles quoted module paths", () => {
	99	+ expect(parseGoModulePath('module "github.com/x/y"\n'))
	100	+ .toBe('github.com/x/y');
	101	+ });
	102	+
	103	+ test("throws when the go.mod has no module directive", () => {
	104	+ expect(() => parseGoModulePath('go 1.22\n')).toThrow(/module/);
	105	+ });
	106	+});
	107	+
	108	+describe("collectGoImports", () => {
	109	+ test("single-line import", () => {
	110	+ expect(collectGoImports('package x\n\nimport "fmt"\n')).toEqual(['fmt']);
	111	+ });
	112	+
	113	+ test("block import", () => {
	114	+ const imports = collectGoImports(`package x
	115	+
	116	+import (
	117	+ "fmt"
	118	+ "strings"
	119	+ "github.com/x/y"
	120	+)
	121	+`);
	122	+ expect(imports).toEqual(['fmt', 'strings', 'github.com/x/y']);
	123	+ });
	124	+
	125	+ test("aliased imports", () => {
	126	+ const imports = collectGoImports(`package x
	127	+
	128	+import (
	129	+ myfmt "fmt"
	130	+ _ "side-effect/pkg"
	131	+)
	132	+`);
	133	+ expect(imports).toEqual(['fmt', 'side-effect/pkg']);
	134	+ });
	135	+
	136	+ test("ignores commented-out imports", () => {
	137	+ const imports = collectGoImports(`package x
	138	+
	139	+// import "ignored"
	140	+import "fmt"
	141	+`);
	142	+ expect(imports).toEqual(['fmt']);
	143	+ });
	144	+});
	145	+
	146	+describe("computeGoGraphDepth — end-to-end on fixture", () => {
	147	+ test("entry → middle → leaf chain produces depth 3", () => {
	148	+ const r = computeGoGraphDepth(FIXTURE);
	149	+ expect(r.language).toBe('go');
	150	+ expect(r.modulePath).toBe('github.com/example/fixture');
	151	+ // Three intra-module package directories: cmd/entry,
	152	+ // internal/middle, internal/leaf. (vendor/some excluded.)
	153	+ expect(r.nodeCount).toBe(3);
	154	+ // Two intra-module edges: cmd/entry → internal/middle,
	155	+ // internal/middle → internal/leaf. (External and vendored
	156	+ // edges excluded; the _test.go edge to middle excluded because
	157	+ // _test.go files are skipped.)
	158	+ expect(r.edgeCount).toBe(2);
	159	+ expect(r.depth).toBe(3);
	160	+ });
	161	+
	162	+ test("result echoes the modulePath so callers can audit", () => {
	163	+ const r = computeGoGraphDepth(FIXTURE);
	164	+ expect(r.modulePath).toBe('github.com/example/fixture');
	165	+ });
	166	+
	167	+ test("re-running on the same tree produces identical numbers", () => {
	168	+ const a = computeGoGraphDepth(FIXTURE);
	169	+ const b = computeGoGraphDepth(FIXTURE);
	170	+ expect(a).toEqual(b);
	171	+ });
	172	+});

added src/c14_go_graph_depth.ts +0 −0

added src/c14_rust_graph_depth.test.ts +199 −0

@@ -0,0 +1,199 @@
	1	+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
	2	+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
	3	+import { tmpdir } from "node:os";
	4	+import { resolve } from "node:path";
	5	+import {
	6	+ computeRustGraphDepth,
	7	+ parseCargoToml,
	8	+} from "./c14_rust_graph_depth.ts";
	9	+
	10	+const FIXTURE = mkdtempSync(resolve(tmpdir(), "tdd-md-rust-graph-"));
	11	+
	12	+const writeFile = (rel: string, content: string): void => {
	13	+ const abs = resolve(FIXTURE, rel);
	14	+ mkdirSync(abs.split("/").slice(0, -1).join("/"), { recursive: true });
	15	+ writeFileSync(abs, content);
	16	+};
	17	+
	18	+beforeAll(() => {
	19	+ // Fixture: a workspace with a root crate + three member crates.
	20	+ // Dependency chain: root → middle → leaf, with `core` standalone.
	21	+ // root (top)
	22	+ // └─→ middle (path)
	23	+ // └─→ leaf (workspace = true)
	24	+ // core (no internal deps)
	25	+ writeFile(
	26	+ "Cargo.toml",
	27	+ `[package]
	28	+name = "rootcrate"
	29	+version = "0.1.0"
	30	+edition = "2021"
	31	+
	32	+[workspace]
	33	+members = [
	34	+ "crates/middle",
	35	+ "crates/leaf",
	36	+ "crates/core",
	37	+]
	38	+
	39	+[workspace.dependencies]
	40	+leaf = { version = "0.1", path = "crates/leaf" }
	41	+
	42	+[dependencies]
	43	+middle = { version = "0.1", path = "crates/middle" }
	44	+serde = "1.0"
	45	+`,
	46	+ );
	47	+ writeFile(
	48	+ "crates/middle/Cargo.toml",
	49	+ `[package]
	50	+name = "middle"
	51	+version = "0.1.0"
	52	+edition = "2021"
	53	+
	54	+[dependencies]
	55	+leaf = { workspace = true }
	56	+anyhow = "1.0"
	57	+`,
	58	+ );
	59	+ writeFile(
	60	+ "crates/leaf/Cargo.toml",
	61	+ `[package]
	62	+name = "leaf"
	63	+version = "0.1.0"
	64	+edition = "2021"
	65	+
	66	+[dependencies]
	67	+log = "0.4"
	68	+`,
	69	+ );
	70	+ writeFile(
	71	+ "crates/core/Cargo.toml",
	72	+ `[package]
	73	+name = "core"
	74	+version = "0.1.0"
	75	+edition = "2021"
	76	+
	77	+[dependencies]
	78	+log = "0.4"
	79	+`,
	80	+ );
	81	+});
	82	+
	83	+afterAll(() => {
	84	+ rmSync(FIXTURE, { recursive: true, force: true });
	85	+});
	86	+
	87	+describe("parseCargoToml", () => {
	88	+ test("extracts a simple [package] name", () => {
	89	+ const doc = parseCargoToml(`[package]\nname = "myseg"\nversion = "0.1.0"\n`);
	90	+ const pkg = doc.sections.get("package");
	91	+ expect(pkg?.get("name")).toBe("myseg");
	92	+ });
	93	+
	94	+ test("extracts a multi-line workspace.members array", () => {
	95	+ const doc = parseCargoToml(`[workspace]
	96	+members = [
	97	+ "crates/a",
	98	+ "crates/b",
	99	+]
	100	+`);
	101	+ const ws = doc.sections.get("workspace");
	102	+ expect(ws?.get("members")).toEqual(["crates/a", "crates/b"]);
	103	+ });
	104	+
	105	+ test("parses an inline-table dependency spec", () => {
	106	+ const doc = parseCargoToml(`[dependencies]
	107	+mydep = { version = "0.1", path = "crates/mydep" }
	108	+`);
	109	+ const deps = doc.sections.get("dependencies");
	110	+ const spec = deps?.get("mydep") as Record<string, string>;
	111	+ expect(spec.version).toBe("0.1");
	112	+ expect(spec.path).toBe("crates/mydep");
	113	+ });
	114	+
	115	+ test("parses workspace = true dep style", () => {
	116	+ const doc = parseCargoToml(`[dependencies]
	117	+foo = { workspace = true }
	118	+`);
	119	+ const deps = doc.sections.get("dependencies");
	120	+ const spec = deps?.get("foo") as Record<string, string>;
	121	+ expect(spec.workspace).toBe("true");
	122	+ });
	123	+});
	124	+
	125	+describe("computeRustGraphDepth — end-to-end on fixture", () => {
	126	+ test("root → middle → leaf chain produces depth 3", () => {
	127	+ const r = computeRustGraphDepth(FIXTURE);
	128	+ expect(r.language).toBe("rust");
	129	+ expect(r.workspaceName).toBe("rootcrate");
	130	+ // 4 crates: rootcrate, middle, leaf, core.
	131	+ expect(r.nodeCount).toBe(4);
	132	+ // 2 internal edges: rootcrate → middle, middle → leaf.
	133	+ // (core has no internal deps; serde/anyhow/log are external.)
	134	+ expect(r.edgeCount).toBe(2);
	135	+ expect(r.depth).toBe(3);
	136	+ });
	137	+
	138	+ test("standalone core crate doesn't contribute to longest path", () => {
	139	+ const r = computeRustGraphDepth(FIXTURE);
	140	+ // core is included as a node (depth-1 leaf) but does not extend
	141	+ // the longest chain. Longest is still rootcrate → middle → leaf.
	142	+ expect(r.depth).toBe(3);
	143	+ });
	144	+
	145	+ test("re-running on the same workspace produces identical numbers", () => {
	146	+ const a = computeRustGraphDepth(FIXTURE);
	147	+ const b = computeRustGraphDepth(FIXTURE);
	148	+ expect(a).toEqual(b);
	149	+ });
	150	+});
	151	+
	152	+describe("computeRustGraphDepth — virtual workspace (no root [package])", () => {
	153	+ const VW = mkdtempSync(resolve(tmpdir(), "tdd-md-rust-virtual-"));
	154	+
	155	+ const writeVW = (rel: string, content: string): void => {
	156	+ const abs = resolve(VW, rel);
	157	+ mkdirSync(abs.split("/").slice(0, -1).join("/"), { recursive: true });
	158	+ writeFileSync(abs, content);
	159	+ };
	160	+
	161	+ beforeAll(() => {
	162	+ writeVW(
	163	+ "Cargo.toml",
	164	+ `[workspace]
	165	+members = ["crates/a", "crates/b"]
	166	+`,
	167	+ );
	168	+ writeVW(
	169	+ "crates/a/Cargo.toml",
	170	+ `[package]
	171	+name = "a"
	172	+version = "0.1.0"
	173	+edition = "2021"
	174	+
	175	+[dependencies]
	176	+b = { path = "../b" }
	177	+`,
	178	+ );
	179	+ writeVW(
	180	+ "crates/b/Cargo.toml",
	181	+ `[package]
	182	+name = "b"
	183	+version = "0.1.0"
	184	+edition = "2021"
	185	+`,
	186	+ );
	187	+ });
	188	+
	189	+ afterAll(() => {
	190	+ rmSync(VW, { recursive: true, force: true });
	191	+ });
	192	+
	193	+ test("virtual workspace: 2 crates, 1 edge, depth 2", () => {
	194	+ const r = computeRustGraphDepth(VW);
	195	+ expect(r.nodeCount).toBe(2);
	196	+ expect(r.edgeCount).toBe(1);
	197	+ expect(r.depth).toBe(2);
	198	+ });
	199	+});

added src/c14_rust_graph_depth.ts +390 −0

@@ -0,0 +1,390 @@
	1	+// c14 — adapter: builds a workspace-crate dependency DAG for a Cargo
	2	+// workspace rooted at a given path, then computes graphDepth via the
	3	+// pure helper in b32_graph_depth_polyglot.ts.
	4	+//
	5	+// Module-granularity per /sama/v2 §5 (operational) — see the comment
	6	+// at the top of b32_graph_depth_polyglot.ts. The TS metric works at
	7	+// file level; Go's natural unit is the package directory; Rust's
	8	+// natural unit is the CRATE (Cargo workspace member). graphDepth
	9	+// here = longest path through the workspace-internal crate
	10	+// dependency graph.
	11	+//
	12	+// Algorithm:
	13	+// 1. Read <root>/Cargo.toml.
	14	+// 2. Identify workspace members:
	15	+// - From [workspace] members = [...] — explicit list.
	16	+// - If the root also has [package], the root itself is a
	17	+// workspace member (a "regular workspace with root crate",
	18	+// as ripgrep is — vs a "virtual workspace" where the root
	19	+// has only [workspace]).
	20	+// 3. For each workspace member, read its own Cargo.toml. Get its
	21	+// crate name from [package] name = "...".
	22	+// 4. Parse the member's [dependencies] (and [dev-dependencies]?
	23	+// — no: graphDepth is about production deps, dev-deps are not
	24	+// part of the runtime DAG). For each dep:
	25	+// - If `path = "../foo"` or `path = "crates/foo"` → resolve
	26	+// to a directory and match it to a workspace-member dir.
	27	+// - If `workspace = true` → look it up in the root's
	28	+// [workspace.dependencies] map; if THAT has `path = "..."`,
	29	+// it's a workspace-internal dep.
	30	+// - Otherwise it's an external crate (crates.io) and excluded.
	31	+// 5. Edges = (importing-crate-name → imported-crate-name).
	32	+// 6. Pass to computeGraphDepth.
	33	+//
	34	+// The TOML subset parsed here is the same shape c14_sama_profile.ts
	35	+// handles for sama.profile.toml: string values, string arrays, and
	36	+// the dotted-section + inline-table forms Cargo manifests use. This
	37	+// adapter has its own scoped parser to avoid coupling the SAMA
	38	+// profile parser to Cargo's idioms.
	39	+
	40	+import { readFileSync, statSync } from "node:fs";
	41	+import { dirname, resolve } from "node:path";
	42	+import {
	43	+ computeGraphDepth,
	44	+ type GraphDepthResult,
	45	+} from "./b32_graph_depth_polyglot.ts";
	46	+
	47	+// — Tiny TOML parser sufficient for Cargo.toml structure ----------
	48	+
	49	+type TomlValue = string \| string[] \| Record<string, string>;
	50	+
	51	+interface TomlDoc {
	52	+ sections: Map<string, Map<string, TomlValue>>;
	53	+}
	54	+
	55	+const stripComment = (line: string): string => {
	56	+ // Cargo manifests don't put '#' inside strings used here.
	57	+ const idx = line.indexOf("#");
	58	+ return idx === -1 ? line : line.slice(0, idx);
	59	+};
	60	+
	61	+const parseInlineTableLoose = (raw: string): Record<string, string> => {
	62	+ // `{ version = "0.4", path = "crates/x", workspace = true }`
	63	+ const t = raw.trim();
	64	+ if (!t.startsWith("{") \|\| !t.endsWith("}")) return {};
	65	+ const inner = t.slice(1, -1).trim();
	66	+ const out: Record<string, string> = {};
	67	+ if (inner === "") return out;
	68	+ // Split on commas not inside quotes.
	69	+ const parts: string[] = [];
	70	+ let cur = "";
	71	+ let inStr = false;
	72	+ let quote = "";
	73	+ for (const ch of inner) {
	74	+ if (inStr) {
	75	+ cur += ch;
	76	+ if (ch === quote) inStr = false;
	77	+ continue;
	78	+ }
	79	+ if (ch === '"' \|\| ch === "'") {
	80	+ inStr = true;
	81	+ quote = ch;
	82	+ cur += ch;
	83	+ continue;
	84	+ }
	85	+ if (ch === ",") {
	86	+ parts.push(cur);
	87	+ cur = "";
	88	+ continue;
	89	+ }
	90	+ cur += ch;
	91	+ }
	92	+ if (cur.trim() !== "") parts.push(cur);
	93	+
	94	+ for (const p of parts) {
	95	+ const eq = p.indexOf("=");
	96	+ if (eq === -1) continue;
	97	+ const key = p.slice(0, eq).trim();
	98	+ const rawVal = p.slice(eq + 1).trim();
	99	+ if ((rawVal.startsWith('"') && rawVal.endsWith('"')) \|\| (rawVal.startsWith("'") && rawVal.endsWith("'"))) {
	100	+ out[key] = rawVal.slice(1, -1);
	101	+ } else if (rawVal === "true" \|\| rawVal === "false") {
	102	+ out[key] = rawVal;
	103	+ } else {
	104	+ // numbers, etc — store raw stringified
	105	+ out[key] = rawVal;
	106	+ }
	107	+ }
	108	+ return out;
	109	+};
	110	+
	111	+export const parseCargoToml = (text: string): TomlDoc => {
	112	+ const sections = new Map<string, Map<string, TomlValue>>();
	113	+ sections.set("__top__", new Map());
	114	+
	115	+ // Stitch multi-line array values (`members = [\n "a",\n "b",\n]`).
	116	+ const physLines = text.split("\n");
	117	+ const logical: string[] = [];
	118	+ let buf = "";
	119	+ let arrayDepth = 0;
	120	+ let inlineDepth = 0;
	121	+ for (const raw of physLines) {
	122	+ const line = stripComment(raw);
	123	+ buf = buf === "" ? line : buf + " " + line;
	124	+ for (const c of line) {
	125	+ if (c === "[") arrayDepth++;
	126	+ else if (c === "]") arrayDepth--;
	127	+ else if (c === "{") inlineDepth++;
	128	+ else if (c === "}") inlineDepth--;
	129	+ }
	130	+ // A line that starts with `[` and ends with `]` and has 0 depth
	131	+ // is a section header — but only if the whole bracketed string
	132	+ // is the line, otherwise it's an array literal mid-line.
	133	+ if (arrayDepth <= 0 && inlineDepth <= 0) {
	134	+ arrayDepth = 0;
	135	+ inlineDepth = 0;
	136	+ logical.push(buf);
	137	+ buf = "";
	138	+ }
	139	+ }
	140	+ if (buf.trim() !== "") logical.push(buf);
	141	+
	142	+ let currentSection = "__top__";
	143	+ const headerRe = /^\s\[\s([^\[\]]+)\s\]\s$/; // [table]
	144	+ const arrayHeaderRe = /^\s\[\[\s([^\[\]]+)\s\]\]\s$/; // [[array-of-tables]]
	145	+ for (const rawLogical of logical) {
	146	+ const line = rawLogical.trim();
	147	+ if (line === "") continue;
	148	+ const ah = arrayHeaderRe.exec(line);
	149	+ if (ah) {
	150	+ // Array-of-tables (e.g. [[bin]], [[test]]). We don't merge
	151	+ // multiple entries — we just route them to a unique scratch
	152	+ // section so their key=value lines don't pollute the
	153	+ // previous [table] (notably [package]).
	154	+ const base = ah[1]!.trim();
	155	+ let i = 0;
	156	+ let key = `__arrtable__${base}_${i}`;
	157	+ while (sections.has(key)) { i++; key = `__arrtable__${base}_${i}`; }
	158	+ currentSection = key;
	159	+ sections.set(currentSection, new Map());
	160	+ continue;
	161	+ }
	162	+ const hm = headerRe.exec(line);
	163	+ if (hm) {
	164	+ currentSection = hm[1]!.trim();
	165	+ if (!sections.has(currentSection)) {
	166	+ sections.set(currentSection, new Map());
	167	+ }
	168	+ continue;
	169	+ }
	170	+ const eq = line.indexOf("=");
	171	+ if (eq === -1) continue;
	172	+ const key = line.slice(0, eq).trim();
	173	+ const rawVal = line.slice(eq + 1).trim();
	174	+ let value: TomlValue;
	175	+ if (rawVal.startsWith("[") && rawVal.endsWith("]")) {
	176	+ // Array. Cargo's [workspace] members = ["crates/x", "crates/y"]
	177	+ // form is what we need; other array shapes are skipped.
	178	+ const inner = rawVal.slice(1, -1).trim();
	179	+ if (inner === "") value = [];
	180	+ else {
	181	+ // Split commas at depth 0.
	182	+ const parts: string[] = [];
	183	+ let cur = "";
	184	+ let depth = 0;
	185	+ let inStr = false;
	186	+ let quote = "";
	187	+ for (const ch of inner) {
	188	+ if (inStr) {
	189	+ cur += ch;
	190	+ if (ch === quote) inStr = false;
	191	+ continue;
	192	+ }
	193	+ if (ch === '"' \|\| ch === "'") {
	194	+ inStr = true;
	195	+ quote = ch;
	196	+ cur += ch;
	197	+ continue;
	198	+ }
	199	+ if (ch === "[" \|\| ch === "{") depth++;
	200	+ else if (ch === "]" \|\| ch === "}") depth--;
	201	+ if (ch === "," && depth === 0) {
	202	+ parts.push(cur);
	203	+ cur = "";
	204	+ continue;
	205	+ }
	206	+ cur += ch;
	207	+ }
	208	+ if (cur.trim() !== "") parts.push(cur);
	209	+ const strings: string[] = [];
	210	+ for (const p of parts) {
	211	+ const t = p.trim();
	212	+ if ((t.startsWith('"') && t.endsWith('"')) \|\| (t.startsWith("'") && t.endsWith("'"))) {
	213	+ strings.push(t.slice(1, -1));
	214	+ }
	215	+ }
	216	+ value = strings;
	217	+ }
	218	+ } else if (rawVal.startsWith("{")) {
	219	+ value = parseInlineTableLoose(rawVal);
	220	+ } else if ((rawVal.startsWith('"') && rawVal.endsWith('"')) \|\| (rawVal.startsWith("'") && rawVal.endsWith("'"))) {
	221	+ value = rawVal.slice(1, -1);
	222	+ } else {
	223	+ // bool / number / unknown — store raw
	224	+ value = rawVal;
	225	+ }
	226	+ sections.get(currentSection)!.set(key, value);
	227	+ }
	228	+ return { sections };
	229	+};
	230	+
	231	+// — Adapter logic --------------------------------------------------
	232	+
	233	+interface WorkspaceMember {
	234	+ name: string; // crate name from its own [package] name
	235	+ dir: string; // repo-relative directory of its Cargo.toml
	236	+ toml: TomlDoc;
	237	+}
	238	+
	239	+const isStringArray = (v: TomlValue \| undefined): v is string[] =>
	240	+ Array.isArray(v) && v.every((x) => typeof x === "string");
	241	+
	242	+const isInlineTable = (v: TomlValue \| undefined): v is Record<string, string> =>
	243	+ typeof v === "object" && !Array.isArray(v) && v !== null;
	244	+
	245	+const collectWorkspaceMembers = (
	246	+ root: string,
	247	+ rootToml: TomlDoc,
	248	+): WorkspaceMember[] => {
	249	+ const out: WorkspaceMember[] = [];
	250	+
	251	+ // Explicit workspace members.
	252	+ const ws = rootToml.sections.get("workspace");
	253	+ const memberDirs: string[] = [];
	254	+ if (ws) {
	255	+ const members = ws.get("members");
	256	+ if (isStringArray(members)) {
	257	+ for (const m of members) memberDirs.push(m);
	258	+ }
	259	+ }
	260	+
	261	+ for (const md of memberDirs) {
	262	+ const memberToml = resolve(root, md, "Cargo.toml");
	263	+ let text: string;
	264	+ try {
	265	+ text = readFileSync(memberToml, "utf8");
	266	+ } catch {
	267	+ continue;
	268	+ }
	269	+ const parsed = parseCargoToml(text);
	270	+ const pkg = parsed.sections.get("package");
	271	+ if (!pkg) continue;
	272	+ const name = pkg.get("name");
	273	+ if (typeof name !== "string") continue;
	274	+ out.push({ name, dir: md, toml: parsed });
	275	+ }
	276	+
	277	+ // If the root itself has [package], the root is also a workspace
	278	+ // member (regular workspace with root crate — ripgrep's shape).
	279	+ const rootPkg = rootToml.sections.get("package");
	280	+ if (rootPkg) {
	281	+ const name = rootPkg.get("name");
	282	+ if (typeof name === "string") {
	283	+ out.push({ name, dir: ".", toml: rootToml });
	284	+ }
	285	+ }
	286	+ return out;
	287	+};
	288	+
	289	+const collectWorkspaceDependencies = (
	290	+ rootToml: TomlDoc,
	291	+): Map<string, Record<string, string>> => {
	292	+ // [workspace.dependencies] section: maps dep-name → inline-table
	293	+ // or string-version. When `workspace = true` is used in a member,
	294	+ // we look here to see if that name maps to a workspace-internal
	295	+ // crate (i.e. has a `path = "..."`).
	296	+ const out = new Map<string, Record<string, string>>();
	297	+ const sec = rootToml.sections.get("workspace.dependencies");
	298	+ if (!sec) return out;
	299	+ for (const [k, v] of sec) {
	300	+ if (isInlineTable(v)) out.set(k, v);
	301	+ else if (typeof v === "string") out.set(k, { version: v });
	302	+ }
	303	+ return out;
	304	+};
	305	+
	306	+const memberHasInternalDep = (
	307	+ member: WorkspaceMember,
	308	+ depName: string,
	309	+ depSpec: TomlValue,
	310	+ byName: Map<string, WorkspaceMember>,
	311	+ workspaceDeps: Map<string, Record<string, string>>,
	312	+): string \| null => {
	313	+ // Returns the workspace-member name this dep resolves to, or null.
	314	+
	315	+ // Case A: inline table with path = "..."
	316	+ if (isInlineTable(depSpec)) {
	317	+ if (depSpec.path) {
	318	+ // Path resolves relative to the importing member's dir.
	319	+ // We don't need the absolute resolution — just need to
	320	+ // identify which workspace member it points at. Match by
	321	+ // dep NAME (since path-style internal deps in Cargo usually
	322	+ // name the dep the same as its crate name).
	323	+ if (byName.has(depName)) return depName;
	324	+ }
	325	+ if (depSpec.workspace === "true") {
	326	+ const ws = workspaceDeps.get(depName);
	327	+ if (ws && ws.path) {
	328	+ if (byName.has(depName)) return depName;
	329	+ }
	330	+ }
	331	+ }
	332	+ // Case B: string version-only (external crate) → not internal.
	333	+ // Case C: `dep = { workspace = true }` already handled above.
	334	+ return null;
	335	+};
	336	+
	337	+export interface RustGraphDepthResult extends GraphDepthResult {
	338	+ language: "rust";
	339	+ workspaceName: string;
	340	+}
	341	+
	342	+export const computeRustGraphDepth = (repoRoot: string): RustGraphDepthResult => {
	343	+ const root = resolve(repoRoot);
	344	+ const rootStat = statSync(root);
	345	+ if (!rootStat.isDirectory()) {
	346	+ throw new Error(`expected a directory, got: ${repoRoot}`);
	347	+ }
	348	+ const rootCargo = readFileSync(resolve(root, "Cargo.toml"), "utf8");
	349	+ const rootToml = parseCargoToml(rootCargo);
	350	+ const rootPkg = rootToml.sections.get("package");
	351	+ const workspaceName = (rootPkg && typeof rootPkg.get("name") === "string"
	352	+ ? (rootPkg.get("name") as string)
	353	+ : (() => {
	354	+ // virtual workspace — use the directory name.
	355	+ const segs = root.split("/");
	356	+ return segs[segs.length - 1] ?? "workspace";
	357	+ })());
	358	+
	359	+ const members = collectWorkspaceMembers(root, rootToml);
	360	+ const byName = new Map<string, WorkspaceMember>();
	361	+ for (const m of members) byName.set(m.name, m);
	362	+
	363	+ const workspaceDeps = collectWorkspaceDependencies(rootToml);
	364	+
	365	+ // Build edges: for each member, scan its [dependencies] entries.
	366	+ const nodes = members.map((m) => m.name);
	367	+ const edges: Array<[string, string]> = [];
	368	+ const seen = new Set<string>();
	369	+
	370	+ for (const m of members) {
	371	+ const deps = m.toml.sections.get("dependencies");
	372	+ if (!deps) continue;
	373	+ for (const [depName, depSpec] of deps) {
	374	+ const target = memberHasInternalDep(m, depName, depSpec, byName, workspaceDeps);
	375	+ if (target === null) continue;
	376	+ if (target === m.name) continue;
	377	+ const key = `${m.name} ${target}`;
	378	+ if (seen.has(key)) continue;
	379	+ seen.add(key);
	380	+ edges.push([m.name, target]);
	381	+ }
	382	+ }
	383	+
	384	+ const result = computeGraphDepth({ nodes, edges });
	385	+ return {
	386	+ ...result,
	387	+ language: "rust",
	388	+ workspaceName,
	389	+ };
	390	+};

raw .diff