codingest 0.1.3__tar.gz → 0.1.4__tar.gz

{codingest-0.1.3 → codingest-0.1.4}/Cargo.lock

@@ -313,7 +313,7 @@ dependencies = [
 
 [[package]]
 name = "codingest"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "aho-corasick",
  "base64",
@@ -345,7 +345,7 @@ dependencies = [
 
 [[package]]
 name = "codingest-cli"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "anyhow",
  "clap",
@@ -357,7 +357,7 @@ dependencies = [
 
 [[package]]
 name = "codingest-mcp"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "anyhow",
  "codingest",
@@ -366,7 +366,7 @@ dependencies = [
 
 [[package]]
 name = "codingest-py"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "codingest",
  "codingest-cli",
@@ -1393,9 +1393,9 @@ dependencies = [
 
 [[package]]
 name = "kglite"
-version = "0.14.5"
+version = "0.15.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e03ddfab585aa45e1f8149d78477b677fd253b9c9b0a8d04bdcd3829c50c8caf"
+checksum = "4ec07586e3dac4fa5dd1e216ac057f41ffe056f95eefc8ddd866f09fd7e48394"
 dependencies = [
  "bzip2",
  "chrono",
@@ -1428,9 +1428,9 @@ dependencies = [
 
 [[package]]
 name = "kglite-mcp-server"
-version = "0.14.5"
+version = "0.15.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67bcf469c57b9c6bdc51493ec362a90c98c085f79a0de75c203dc42e3612b6ea"
+checksum = "f9dae485f96add5453ef56518cd14e57c3f20727c8ab151500cc6f1afb70deef"
 dependencies = [
  "anyhow",
  "bytes",
@@ -1532,9 +1532,9 @@ dependencies = [
 
 [[package]]
 name = "mcp-methods"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccd3c31a95d7775d6d930a174aeffdc416c2ad6ffce0eee1cad262a007340175"
+checksum = "04c1063113c3a885d5967e45da2ea1cbb235938a9ba02333f15e81149b451b23"
 dependencies = [
  "anyhow",
  "clap",

codingest-0.1.4/Cargo.toml

@@ -0,0 +1,40 @@
+[workspace]
+members = ["crates/codingest", "crates/codingest-cli", "crates/codingest-mcp", "crates/codingest-py"]
+resolver = "2"
+
+[workspace.package]
+version = "0.1.4"
+edition = "2021"
+rust-version = "1.88"
+license = "MIT"
+repository = "https://github.com/kkollsga/codingest"
+
+[workspace.dependencies]
+base64 = "0.22"
+sha2 = "0.11"
+# kglite engine + MCP server — imported as crates.io libraries. The 0.15.3
+# floor brings tri-state `durable` levels with an on-demand `sync()` barrier,
+# typed constraint/conflict exceptions carrying a stable `.code`, and the
+# columnar-REMOVE correctness fix, on top of the generic workspace-graph hooks
+# and deterministic Postcard persistence stack inherited from 0.14.5. The
+# 0.15.1-0.15.3 patches add a declared `rust-version = 1.88.0` on both crates we
+# consume (matching our own floor), fix a `storage="disk"` save that could emit
+# a directory the same build could not load, widen the unknown-label diagnostic
+# to subqueries, and correct understated dependency floors — with no change to
+# `kglite::api`, graph output, property encoding, or `.kgl` serialization.
+# Keep both libraries aligned so the graph and server share one engine release.
+kglite = { version = "0.15.3", default-features = false }
+kglite-mcp-server = { version = "0.15.3", default-features = false }
+
+# Mirror KGLite's release codegen so the standalone builder has
+# performance parity with the in-tree component (see KGLite
+# workspace Cargo.toml).
+[profile.release]
+lto = "thin"
+codegen-units = 1
+strip = "symbols"
+
+[profile.profiling]
+inherits = "release"
+debug = "line-tables-only"
+strip = "none"

{codingest-0.1.3 → codingest-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codingest
-Version: 0.1.3
+Version: 0.1.4
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
-Requires-Dist: kglite>=0.14.5,<0.15
+Requires-Dist: kglite>=0.15.3,<0.16
 License-File: LICENSE
 Summary: Build fast, queryable code graphs for AI agents, MCP code review, and local or GitHub repository analysis.
 Keywords: ai-agents,mcp,code-review,knowledge-graph,code-analysis,github,tree-sitter,cypher
@@ -180,7 +180,7 @@ codingest skill install        # code-review Agent Skill
 ```
 
 The wheel bundles every grammar plus the `codingest` and `codingest-mcp`
-commands. KGLite ≥0.14.5 is installed automatically as the query/storage
+commands. KGLite ≥0.15.3 is installed automatically as the query/storage
 engine; its MCP server and the transitive `mcp-methods` framework power the
 builder-aware Codingest server. Nothing else needs to be installed.
 
@@ -193,7 +193,7 @@ Python prerequisites.
 ```toml
 [dependencies]
 codingest = "0.1"
-kglite = "0.14.5"
+kglite = "0.15.3"
 ```
 
 ```rust
@@ -237,23 +237,35 @@ cargo test --workspace
 cargo test -p codingest --test parity
 ```
 
-### The golden-digest oracle
+### The golden-digest oracle (also the determinism gate)
 
 KGLite deleted its in-tree `code_tree` builder on 2026-07-16, so the old
 two-builder parity sweep is gone. The authority it enforced was **frozen** while
 the builders were still verified identical, into per-corpus SHA-256 digests
 under `crates/codingest/tests/goldens/` (committed fixtures — no network). The
-`golden_parity` test builds each corpus with only the codingest builder, digests
-a canonical exhaustive graph rendering, and compares to the frozen golden. The
-multi-rev fixture is guarded instead by `rev_self_consistency`. Regenerate
-goldens only for deliberate builder-behavior changes:
+`golden_parity` test builds each corpus **three times** with only the codingest
+builder, digests a canonical exhaustive graph rendering, and requires every
+build to match every other build *and* the frozen golden. Repeating the build is
+what makes this the determinism gate: hash iteration order is randomized per
+`HashMap`, so an order-dependent builder fails it (the
+`tests/corpus/dup_minified_assets` fixture reproduces the original DEFINES-edge
+nondeterminism bug). Disagreement between builds is reported as NONDETERMINISM;
+agreement between builds but not with the golden is reported as a behaviour
+change. The multi-rev fixture is guarded instead by `rev_self_consistency`.
+Regenerate goldens only for deliberate builder-behavior changes:
 `cargo test -p codingest --test parity -- --ignored capture_goldens` (details in
 `crates/codingest/tests/goldens/README.md`).
 
+Everything the gate needs is committed to this repository, so it is hermetic and
+runs in CI. It replaced a local-only `make` step that asserted an exact edge
+count against a *sibling* checkout — a verdict this project did not control.
+`make determinism-soak REPO=…` keeps the large-repo reproducer available as a
+diagnostic.
+
 ## Dependency policy
 
 `kglite` and `kglite-mcp-server` use matching crates.io requirements with a
-0.14.5 minimum and a shared lockfile. This keeps the builder, persistence
+0.15.3 minimum and a shared lockfile. This keeps the builder, persistence
 handoff, and embedded MCP server on one compatible engine patch line.
 
 ## Parity with the (now-removed) in-tree component

{codingest-0.1.3 → codingest-0.1.4}/README.md

@@ -153,7 +153,7 @@ codingest skill install        # code-review Agent Skill
 ```
 
 The wheel bundles every grammar plus the `codingest` and `codingest-mcp`
-commands. KGLite ≥0.14.5 is installed automatically as the query/storage
+commands. KGLite ≥0.15.3 is installed automatically as the query/storage
 engine; its MCP server and the transitive `mcp-methods` framework power the
 builder-aware Codingest server. Nothing else needs to be installed.
 
@@ -166,7 +166,7 @@ Python prerequisites.
 ```toml
 [dependencies]
 codingest = "0.1"
-kglite = "0.14.5"
+kglite = "0.15.3"
 ```
 
 ```rust
@@ -210,23 +210,35 @@ cargo test --workspace
 cargo test -p codingest --test parity
 ```
 
-### The golden-digest oracle
+### The golden-digest oracle (also the determinism gate)
 
 KGLite deleted its in-tree `code_tree` builder on 2026-07-16, so the old
 two-builder parity sweep is gone. The authority it enforced was **frozen** while
 the builders were still verified identical, into per-corpus SHA-256 digests
 under `crates/codingest/tests/goldens/` (committed fixtures — no network). The
-`golden_parity` test builds each corpus with only the codingest builder, digests
-a canonical exhaustive graph rendering, and compares to the frozen golden. The
-multi-rev fixture is guarded instead by `rev_self_consistency`. Regenerate
-goldens only for deliberate builder-behavior changes:
+`golden_parity` test builds each corpus **three times** with only the codingest
+builder, digests a canonical exhaustive graph rendering, and requires every
+build to match every other build *and* the frozen golden. Repeating the build is
+what makes this the determinism gate: hash iteration order is randomized per
+`HashMap`, so an order-dependent builder fails it (the
+`tests/corpus/dup_minified_assets` fixture reproduces the original DEFINES-edge
+nondeterminism bug). Disagreement between builds is reported as NONDETERMINISM;
+agreement between builds but not with the golden is reported as a behaviour
+change. The multi-rev fixture is guarded instead by `rev_self_consistency`.
+Regenerate goldens only for deliberate builder-behavior changes:
 `cargo test -p codingest --test parity -- --ignored capture_goldens` (details in
 `crates/codingest/tests/goldens/README.md`).
 
+Everything the gate needs is committed to this repository, so it is hermetic and
+runs in CI. It replaced a local-only `make` step that asserted an exact edge
+count against a *sibling* checkout — a verdict this project did not control.
+`make determinism-soak REPO=…` keeps the large-repo reproducer available as a
+diagnostic.
+
 ## Dependency policy
 
 `kglite` and `kglite-mcp-server` use matching crates.io requirements with a
-0.14.5 minimum and a shared lockfile. This keeps the builder, persistence
+0.15.3 minimum and a shared lockfile. This keeps the builder, persistence
 handoff, and embedded MCP server on one compatible engine patch line.
 
 ## Parity with the (now-removed) in-tree component

{codingest-0.1.3 → codingest-0.1.4}/crates/codingest/Cargo.toml

@@ -9,8 +9,8 @@ description = "codingest — standalone extraction of KGLite's code-tree compone
 keywords = ["knowledge-graph", "code-analysis", "tree-sitter", "cypher", "kglite"]
 categories = ["development-tools", "parser-implementations"]
 
-# Requires the kglite 0.14 engine API (`kglite::api::code_entities`); the
-# workspace pins the current 0.14 patch floor.
+# Requires the kglite 0.15 engine API (`kglite::api::code_entities`); the
+# workspace pins the current 0.15 patch floor (0.15.3).
 
 [lib]
 name = "codingest"

{codingest-0.1.3 → codingest-0.1.4}/crates/codingest/src/bin/codingest_bench.rs

@@ -16,16 +16,41 @@
 //! MISMATCH is a query-result determinism regression, and the A/B delta is
 //! run-to-run timing variance. The release gate fails on any MISMATCH.
 //!
+//! # The corpus is defined by the harness, not by the working directory
+//!
+//! A benchmark number is comparable to another only if both were measured on
+//! the same input. The builder walks whatever is on disk: it skips dot-dirs,
+//! `target/`, `node_modules/`, `venv/` and `__pycache__/` by name, but it has
+//! no notion of `.gitignore`, so a repository's *untracked* working state
+//! (scratch folders, local notes, generated markdown) is ingested — notably
+//! through the docs pass. Benchmarking a working tree therefore measures a
+//! corpus nobody else can reconstruct. Measured on this workspace: a clean
+//! `git worktree` of a commit scored 1,115 nodes / 3,692 edges while the
+//! working tree at that same commit scored 1,170 / 3,759 — a ~5% swing with no
+//! builder or engine involvement, which silently invalidated published numbers.
+//!
+//! So this harness defines its own corpus. By default it materializes the
+//! target's **git-tracked** files into a temporary directory and builds that:
+//! the input is then a function of the committed content plus any uncommitted
+//! edits to tracked files, reproducible on any machine at the same revision.
+//! Every run prints `corpus_sha256`, so two numbers can be *checked* for
+//! comparability rather than assumed comparable. `--include-untracked` restores
+//! the old build-the-directory-as-is behaviour for a one-off measurement of a
+//! non-git tree, and prints a NOT-REPRODUCIBLE banner.
+//!
 //! Usage:
 //!   cargo run -p codingest --bin codingest_bench --release -- <path>
 //!   cargo run -p codingest --bin codingest_bench --release -- <path> --json
+//!   cargo run -p codingest --bin codingest_bench --release -- <path> --include-untracked
 
 use kglite::api::session::{execute_read, ExecuteOptions, ExecuteOutcome};
 use kglite::api::{DirGraph, GraphRead, Value};
+use sha2::{Digest, Sha256};
 use std::collections::hash_map::DefaultHasher;
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
-use std::path::Path;
+use std::path::{Path, PathBuf};
+use std::process::Command;
 use std::time::Instant;
 
 const WARMUP: usize = 3;
@@ -92,6 +117,153 @@ fn min(v: &[f64]) -> f64 {
     v.iter().cloned().fold(f64::INFINITY, f64::min)
 }
 
+// ── corpus selection ─────────────────────────────────────────────────────
+
+/// How the benchmark input was assembled. See the module docs.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum CorpusMode {
+    /// Git-tracked files of the target, copied into a tempdir. Reproducible.
+    TrackedOnly,
+    /// The target directory exactly as it sits on disk. Not reproducible if
+    /// the tree carries untracked or git-ignored content.
+    WorkingTree,
+}
+
+impl CorpusMode {
+    fn as_str(self) -> &'static str {
+        match self {
+            CorpusMode::TrackedOnly => "tracked-only",
+            CorpusMode::WorkingTree => "working-tree",
+        }
+    }
+}
+
+/// The resolved benchmark input: the directory to build, plus the identity of
+/// the content in it.
+struct Corpus {
+    build_dir: PathBuf,
+    mode: CorpusMode,
+    /// Why we ended up in `mode` — printed so the choice is never silent.
+    reason: String,
+    files: usize,
+    bytes: u64,
+    /// `None` in `WorkingTree` mode: the ingested set is not enumerable
+    /// without duplicating the builder's walk, and an approximate identity is
+    /// worse than an explicit absence.
+    sha256: Option<String>,
+    /// Owns the tempdir for the process lifetime; dropping it deletes the copy.
+    _tmp: Option<tempfile::TempDir>,
+}
+
+fn hex(bytes: &[u8]) -> String {
+    bytes.iter().map(|b| format!("{b:02x}")).collect()
+}
+
+/// Git-tracked paths under `target`, relative to it. `None` when `target` is
+/// not inside a git work tree (or git is unavailable).
+fn git_tracked_files(target: &Path) -> Option<Vec<String>> {
+    let out = Command::new("git")
+        .arg("-C")
+        .arg(target)
+        .args(["ls-files", "-z", "--cached"])
+        .output()
+        .ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    let stdout = String::from_utf8(out.stdout).ok()?;
+    Some(
+        stdout
+            .split('\0')
+            .filter(|s| !s.is_empty())
+            .map(str::to_string)
+            .collect(),
+    )
+}
+
+/// Copy `rels` (relative to `target`) into a fresh tempdir and return the
+/// corpus, including a content digest over the sorted `(path, sha256(bytes))`
+/// pairs. Two runs with the same digest measured the same input.
+fn materialize_tracked(target: &Path, mut rels: Vec<String>) -> std::io::Result<Corpus> {
+    rels.sort();
+    let tmp = tempfile::Builder::new()
+        .prefix("codingest-bench-corpus-")
+        .tempdir()?;
+    let root = tmp.path().to_path_buf();
+
+    let mut manifest = Sha256::new();
+    let mut files = 0usize;
+    let mut bytes = 0u64;
+
+    for rel in &rels {
+        let src = target.join(rel);
+        // `ls-files` lists index entries; a tracked-but-deleted file, or a
+        // gitlink (submodule) directory, has nothing to copy.
+        let Ok(data) = std::fs::read(&src) else {
+            continue;
+        };
+        let dst = root.join(rel);
+        if let Some(parent) = dst.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        std::fs::write(&dst, &data)?;
+
+        let mut file_hash = Sha256::new();
+        file_hash.update(&data);
+        manifest.update(rel.as_bytes());
+        manifest.update(b"\0");
+        manifest.update(hex(&file_hash.finalize()).as_bytes());
+        manifest.update(b"\n");
+
+        files += 1;
+        bytes += data.len() as u64;
+    }
+
+    Ok(Corpus {
+        build_dir: root,
+        mode: CorpusMode::TrackedOnly,
+        reason: format!("git-tracked content of {}", target.display()),
+        files,
+        bytes,
+        sha256: Some(hex(&manifest.finalize())),
+        _tmp: Some(tmp),
+    })
+}
+
+/// Resolve the benchmark input for `target`.
+///
+/// Default is `TrackedOnly`; it degrades to `WorkingTree` only when the target
+/// is not in a git work tree, and says so. `--include-untracked` forces
+/// `WorkingTree`.
+fn resolve_corpus(target: &Path, include_untracked: bool) -> Corpus {
+    let working_tree = |reason: String| Corpus {
+        build_dir: target.to_path_buf(),
+        mode: CorpusMode::WorkingTree,
+        reason,
+        files: 0,
+        bytes: 0,
+        sha256: None,
+        _tmp: None,
+    };
+
+    if include_untracked {
+        return working_tree("--include-untracked requested".to_string());
+    }
+    let Some(rels) = git_tracked_files(target) else {
+        return working_tree(format!("{} is not in a git work tree", target.display()));
+    };
+    if rels.is_empty() {
+        return working_tree(format!("git tracks no files under {}", target.display()));
+    }
+    match materialize_tracked(target, rels) {
+        Ok(corpus) => corpus,
+        Err(e) => {
+            eprintln!("warning: could not materialize the tracked-only corpus: {e}");
+            working_tree(format!("tracked-only materialization failed: {e}"))
+        }
+    }
+}
+
 struct QueryResult {
     name: String,
     rows: usize,
@@ -114,12 +286,30 @@ fn main() {
     };
     let rest: Vec<String> = args.collect();
     let json = rest.iter().any(|a| a == "--json");
+    let include_untracked = rest.iter().any(|a| a == "--include-untracked");
+    // Reject unknown flags rather than silently ignoring them: a typo'd
+    // `--include-untraked` would otherwise change nothing and be reported as a
+    // measurement taken under a mode it never ran in.
+    if let Some(bad) = rest
+        .iter()
+        .find(|a| !matches!(a.as_str(), "--json" | "--include-untracked"))
+    {
+        eprintln!("unknown argument `{bad}`");
+        eprintln!("usage: codingest_bench <path> [--json] [--include-untracked]");
+        std::process::exit(2);
+    }
     let target = Path::new(&path);
 
+    // Resolve the corpus BEFORE any timing: by default this copies the
+    // target's git-tracked files into a tempdir so the measured input is
+    // reproducible from the revision alone (see the module docs).
+    let corpus = resolve_corpus(target, include_untracked);
+    let build_dir = corpus.build_dir.as_path();
+
     // Two independent codingest builds with identical arguments:
     // verbose=false, include_tests=false, save_to=None, max_loc=None, docs=true.
     let t = Instant::now();
-    let graph_a = codingest::builder::run_with_options(target, false, false, None, None, true)
+    let graph_a = codingest::builder::run_with_options(build_dir, false, false, None, None, true)
         .unwrap_or_else(|e| {
             eprintln!("build A failed: {e}");
             std::process::exit(1);
@@ -127,7 +317,7 @@ fn main() {
     let build_a_secs = t.elapsed().as_secs_f64();
 
     let t = Instant::now();
-    let graph_b = codingest::builder::run_with_options(target, false, false, None, None, true)
+    let graph_b = codingest::builder::run_with_options(build_dir, false, false, None, None, true)
         .unwrap_or_else(|e| {
             eprintln!("build B failed: {e}");
             std::process::exit(1);
@@ -291,6 +481,11 @@ fn main() {
     if json {
         let out = serde_json::json!({
             "path": path,
+            "corpus_mode": corpus.mode.as_str(),
+            "corpus_reason": corpus.reason,
+            "corpus_files": corpus.sha256.as_ref().map(|_| corpus.files),
+            "corpus_bytes": corpus.sha256.as_ref().map(|_| corpus.bytes),
+            "corpus_sha256": corpus.sha256,
             "nodes": nodes,
             "edges": edges,
             "build_a_secs": (build_a_secs * 1000.0).round() / 1000.0,
@@ -316,6 +511,22 @@ fn main() {
 
     println!("codingest Cypher benchmark — query-parity across two independent builds");
     println!("target : {path}");
+    match &corpus.sha256 {
+        Some(digest) => println!(
+            "corpus : {} — {} files, {} bytes, sha256 {}\n         ({})",
+            corpus.mode.as_str(),
+            corpus.files,
+            corpus.bytes,
+            digest,
+            corpus.reason,
+        ),
+        None => println!(
+            "corpus : {} — NOT REPRODUCIBLE: untracked and git-ignored content \
+             is ingested\n         ({})",
+            corpus.mode.as_str(),
+            corpus.reason,
+        ),
+    }
     println!("graph  : {nodes} nodes / {edges} edges  (identical across both builds)");
     println!("build  : A {build_a_secs:.3}s | B {build_b_secs:.3}s  (one-off, context)");
     println!("anchor : in-hub  = {hot_in}");

{codingest-0.1.3 → codingest-0.1.4}/crates/codingest/src/rev.rs

@@ -278,8 +278,14 @@ fn stamp_rev_provenance(
 // One graph holding N revisions via shared identity + rev-sets: one node per
 // entity, native list props `revs: [str]` / `rev_fp: [int]` on nodes and
 // `revs: [str]` on edges. Unchanged entities are stored once, so the merged
-// graph is ≈ base + deltas. See `dev-docs/plans/rev-aware-code-graphs.md`
-// "B.2 design" for the eight settled decisions.
+// graph is ≈ base + deltas.
+//
+// This comment is deliberately self-contained. It used to defer to a
+// `dev-docs/plans/` design doc for the settled decisions — but `dev-docs/` is
+// gitignored working state, so the citation outlived the file it pointed at and
+// became a dead reference for every reader who cloned this repo. Committed code
+// does not cite `dev-docs/` paths; anything a reader needs belongs here, and
+// anything durable enough to survive belongs in a committed doc.
 
 /// Collapse a requested rev-label list to its order-preserving unique form
 /// (first occurrence wins). A duplicate label resolves to the same tree, so

{codingest-0.1.3 → codingest-0.1.4}/crates/codingest/tests/goldens/README.md

@@ -25,6 +25,14 @@ in-tree vs codingest check) is gone. `golden_parity` — which builds each corpu
 with only the `codingest` builder and compares to these frozen digests — is now
 the sole guardian that codingest still produces the historically-correct graph.
 
+`golden_parity` builds each corpus **three times** (`BUILDS_PER_CORPUS`), so it
+is also the builder-determinism gate: hash iteration order is randomized per
+`HashMap` instance, and `dup_minified_assets` reproduces the DEFINES-edge
+ordering bug that once flapped edge totals run-to-run. A disagreement *between
+builds* is nondeterminism and is never a reason to regenerate; agreement between
+builds that differs from the golden is a behaviour change and may be. The test
+reports the two cases distinctly.
+
 ## Regenerating (deliberate builder-behavior changes only)
 
 Do **not** regenerate to make a red `golden_parity` go green. A digest change

{codingest-0.1.3 → codingest-0.1.4}/crates/codingest/tests/parity.rs

@@ -9,9 +9,18 @@
 //! builders were still verified-identical) into per-corpus SHA-256 golden
 //! digests, and the surviving tests carry it forward:
 //!
-//!   * `golden_parity` builds each corpus once with `codingest` and asserts
-//!     its canonical digest matches the frozen golden (see
-//!     `tests/goldens/README.md`).
+//!   * `golden_parity` builds each corpus `BUILDS_PER_CORPUS` times with
+//!     `codingest` and asserts every build's canonical digest matches the
+//!     frozen golden (see `tests/goldens/README.md`). Repeating the build is
+//!     what makes this the project's **determinism** gate as well: hash
+//!     iteration order is randomized per `HashMap` instance, so an
+//!     order-dependent builder produces digests that disagree with each other
+//!     (reported as NONDETERMINISM) or agree with each other but not the
+//!     golden (reported as a behaviour change). This replaced a Makefile-only
+//!     step that ran three builds of an *external sibling checkout* and pinned
+//!     its exact edge count — a gate whose verdict depended on a repository
+//!     this project does not own, which never ran in CI, and which skipped
+//!     silently when the checkout was absent.
 //!   * `rev_self_consistency` builds the same 2-commit tempdir repo twice with
 //!     `codingest` and asserts the graphs are equivalent — INCLUDING the
 //!     `revs` / `rev_fp` list properties stamped onto every node and edge — a
@@ -45,6 +54,20 @@ const CORPORA: &[&str] = &[
     "agc_basic",
 ];
 
+/// Independent builds of each corpus per `golden_parity` run.
+///
+/// One build proves the output still matches the frozen golden; repeating it
+/// also proves the output does not depend on hash iteration order. The
+/// original nondeterminism bug (randomized `HashMap` iteration over DEFINES
+/// (source_type, target_type) pairs — whichever pair went first got
+/// skip-existence-check dedup semantics) is reproduced by the
+/// `dup_minified_assets` corpus, which defines the same selector/element id
+/// from one file more than once. Three builds is enough to make an
+/// order-dependent builder fail loudly and quickly; the digest comparison
+/// against the golden catches the residual case where all three happen to
+/// agree on a wrong order.
+const BUILDS_PER_CORPUS: usize = 3;
+
 fn corpus_root() -> PathBuf {
     // tests/parity.rs lives in crates/code-tree; corpus is at the workspace root.
     Path::new(env!("CARGO_MANIFEST_DIR"))
@@ -229,62 +252,62 @@ fn read_golden(corpus: &str) -> String {
 
 /// Assert the two graphs are equivalent along every dimension, with
 /// pinpointed diffs on failure.
-fn assert_graphs_equiv(label: &str, in_tree: &DirGraph, standalone: &DirGraph) {
+fn assert_graphs_equiv(label: &str, left: &DirGraph, right: &DirGraph) {
     // 1. node-type counts
-    let (a, b) = (node_type_counts(in_tree), node_type_counts(standalone));
+    let (a, b) = (node_type_counts(left), node_type_counts(right));
     assert_eq!(
         a, b,
-        "[{label}] node-type counts differ\nin-tree={a:?}\nstandalone={b:?}"
+        "[{label}] node-type counts differ\nleft={a:?}\nright={b:?}"
     );
 
     // 2. edge-type counts
-    let (a, b) = (edge_type_counts(in_tree), edge_type_counts(standalone));
+    let (a, b) = (edge_type_counts(left), edge_type_counts(right));
     assert_eq!(
         a, b,
-        "[{label}] edge-type counts differ\nin-tree={a:?}\nstandalone={b:?}"
+        "[{label}] edge-type counts differ\nleft={a:?}\nright={b:?}"
     );
 
     // 3. node identity set
-    let (a, b) = (node_identities(in_tree), node_identities(standalone));
+    let (a, b) = (node_identities(left), node_identities(right));
     if a != b {
         let only_in: Vec<_> = a.iter().filter(|x| !b.contains(x)).take(10).collect();
         let only_st: Vec<_> = b.iter().filter(|x| !a.contains(x)).take(10).collect();
         panic!(
-            "[{label}] node identity sets differ\nonly in-tree (<=10): {only_in:?}\nonly standalone (<=10): {only_st:?}"
+            "[{label}] node identity sets differ\nonly left (<=10): {only_in:?}\nonly right (<=10): {only_st:?}"
         );
     }
 
     // 4. per-node property sweep
-    let (a, b) = (node_props(in_tree), node_props(standalone));
+    let (a, b) = (node_props(left), node_props(right));
     if a != b {
         for (x, y) in a.iter().zip(b.iter()) {
             if x != y {
                 panic!(
-                    "[{label}] node properties differ\nfirst mismatch:\n  in-tree=({}, {}) {:?}\n  standalone=({}, {}) {:?}",
+                    "[{label}] node properties differ\nfirst mismatch:\n  left=({}, {}) {:?}\n  right=({}, {}) {:?}",
                     x.0, x.1, x.2, y.0, y.1, y.2
                 );
             }
         }
         panic!(
-            "[{label}] node property lists differ in length: in-tree={} standalone={}",
+            "[{label}] node property lists differ in length: left={} right={}",
             a.len(),
             b.len()
         );
     }
 
     // 5. per-edge property sweep
-    let (a, b) = (edge_props(in_tree), edge_props(standalone));
+    let (a, b) = (edge_props(left), edge_props(right));
     if a != b {
         for (x, y) in a.iter().zip(b.iter()) {
             if x != y {
                 panic!(
-                    "[{label}] edge properties differ\nfirst mismatch:\n  in-tree=({}, {}->{}) {:?}\n  standalone=({}, {}->{}) {:?}",
+                    "[{label}] edge properties differ\nfirst mismatch:\n  left=({}, {}->{}) {:?}\n  right=({}, {}->{}) {:?}",
                     x.0, x.1, x.2, x.3, y.0, y.1, y.2, y.3
                 );
             }
         }
         panic!(
-            "[{label}] edge property lists differ in length: in-tree={} standalone={}",
+            "[{label}] edge property lists differ in length: left={} right={}",
             a.len(),
             b.len()
         );
@@ -298,6 +321,12 @@ fn assert_graphs_equiv(label: &str, in_tree: &DirGraph, standalone: &DirGraph) {
 // (see `tests/goldens/README.md`). This is the test that carries the
 // authority forward now that KGLite has deleted its in-tree builder: it keeps
 // proving that codingest reproduces the frozen graph byte-for-byte.
+//
+// It is also the determinism gate: each corpus is built `BUILDS_PER_CORPUS`
+// times and every build must produce the same digest as every other *and* as
+// the golden. The two failure modes are reported separately, because they call
+// for opposite responses — a behaviour change may be legitimate and
+// regenerated, while nondeterminism is always a bug.
 #[test]
 fn golden_parity() {
     let root = corpus_root();
@@ -305,14 +334,40 @@ fn golden_parity() {
         let dir = root.join(name);
         assert!(dir.is_dir(), "missing corpus dir: {}", dir.display());
 
-        let g = codingest::builder::run_with_options(&dir, false, true, None, None, true)
-            .unwrap_or_else(|e| panic!("[{name}] codingest build failed: {e}"));
-        let got = graph_digest(&g);
+        let build = || {
+            codingest::builder::run_with_options(&dir, false, true, None, None, true)
+                .unwrap_or_else(|e| panic!("[{name}] codingest build failed: {e}"))
+        };
+
+        let first = build();
+        let got = graph_digest(&first);
+
+        // 1. Determinism: repeat builds must be identical to the first.
+        for run in 2..=BUILDS_PER_CORPUS {
+            let again = build();
+            let again_digest = graph_digest(&again);
+            if again_digest != got {
+                // Pinpoint the divergence before reporting it.
+                assert_graphs_equiv(
+                    &format!("{name} nondeterminism run 1 vs {run}"),
+                    &first,
+                    &again,
+                );
+                panic!(
+                    "[{name}] NONDETERMINISM: build 1 and build {run} of the same corpus \
+                     produced different digests ({got} != {again_digest}) but compared equal \
+                     dimension-by-dimension — widen the canonical rendering."
+                );
+            }
+        }
+
+        // 2. Frozen authority: the (now proven stable) digest must be the golden.
         let want = read_golden(name);
         assert_eq!(
             got, want,
             "[{name}] golden digest mismatch\n  golden (frozen authority) = {want}\n  codingest build           = {got}\n\
-             If this change to builder behavior is deliberate, regenerate with\n\
+             All {BUILDS_PER_CORPUS} builds agreed, so this is a builder BEHAVIOUR change, not nondeterminism.\n\
+             If it is deliberate, regenerate with\n\
              `cargo test -p codingest --test parity -- --ignored capture_goldens`."
         );
     }

{codingest-0.1.3 → codingest-0.1.4}/crates/codingest-cli/Cargo.toml

@@ -14,7 +14,7 @@ name = "codingest"
 path = "src/main.rs"
 
 [dependencies]
-codingest = { version = "0.1.0", path = "../codingest" }
+codingest = { version = "0.1.4", path = "../codingest" }
 kglite = { workspace = true }
 anyhow = "1"
 clap = { version = "4", features = ["derive"] }

{codingest-0.1.3 → codingest-0.1.4}/crates/codingest-mcp/Cargo.toml

@@ -14,6 +14,6 @@ name = "codingest-mcp"
 path = "src/main.rs"
 
 [dependencies]
-codingest = { version = "0.1.0", path = "../codingest" }
+codingest = { version = "0.1.4", path = "../codingest" }
 kglite-mcp-server = { workspace = true }
 anyhow = "1"

{codingest-0.1.3 → codingest-0.1.4}/crates/codingest-py/Cargo.toml

@@ -42,7 +42,7 @@ doctest = false
 pyo3 = { version = "0.29" }
 # The engine-free builder (parsers, call/type/route edges, rev merge, repo
 # clone, manifest reader). Docs pass gated by this crate's `docs` feature.
-codingest = { version = "0.1.0", path = "../codingest", default-features = false }
+codingest = { version = "0.1.4", path = "../codingest", default-features = false }
 # `.kgl` persistence (`kglite::api::io::save_graph`) for the serialize half of
 # the build-then-load handoff, plus the `DirGraph` type the builder returns.
 kglite = { workspace = true }
@@ -53,9 +53,9 @@ tempfile = "3"
 # through `_run_cli`, so `pip install codingest` also installs the `codingest`
 # command without a second wheel or a duplicated builder build. Mirrors
 # kglite-py's `kglite-cli` bundling.
-codingest-cli = { version = "0.1.0", path = "../codingest-cli" }
+codingest-cli = { version = "0.1.4", path = "../codingest-cli" }
 # Source-building MCP composition. The graph server and generic MCP lifecycle
 # remain owned by its existing kglite-mcp-server -> mcp-methods Rust dependency
 # chain; linking this thin library into the extension gives pip users the same
 # builder-aware server as the standalone `codingest-mcp` binary.
-codingest-mcp = { version = "0.1.0", path = "../codingest-mcp" }
+codingest-mcp = { version = "0.1.4", path = "../codingest-mcp" }

{codingest-0.1.3 → codingest-0.1.4}/crates/codingest-py/src/lib.rs

@@ -67,7 +67,7 @@ fn load_via_kglite(py: Python<'_>, path: &Path) -> PyResult<Py<PyAny>> {
     let kglite = py.import("kglite").map_err(|e| {
         PyRuntimeError::new_err(format!(
             "codingest.build() returns a kglite.KnowledgeGraph, but importing \
-             `kglite` failed ({e}). Install it: `pip install kglite>=0.14.5`."
+             `kglite` failed ({e}). Install it: `pip install kglite>=0.15.3`."
         ))
     })?;
     let graph = kglite.call_method1("load", (path.to_string_lossy().as_ref(),))?;

{codingest-0.1.3 → codingest-0.1.4}/pyproject.toml

@@ -34,8 +34,17 @@ dynamic = ["version"]
 # `load()`. So the returned object is a real `kglite.KnowledgeGraph`, and the
 # wheel depends on kglite at runtime. Keep the Python engine aligned with the
 # Rust crates so both halves use the same persistence and MCP fixes.
+#
+# The upper bound is a `.kgl` format guard, not stylistic. The two halves of
+# this handoff are versioned independently: the *Rust* kglite compiled into
+# this wheel writes the bytes, and the separately-installed *Python* kglite
+# wheel reads them. KGLite deliberately hard-breaks the `.kgl` format across
+# minor releases (e.g. the v3->v4 break, which refuses old files outright), so
+# pip must never be free to pair our writer with a reader from a different
+# minor. This range therefore mirrors the Cargo semver range for the pin above
+# (`version = "0.15.3"` == `>=0.15.3,<0.16.0`) exactly — bump both together.
 dependencies = [
-    "kglite>=0.14.5,<0.15",
+    "kglite>=0.15.3,<0.16",
 ]
 
 [project.urls]

codingest-0.1.3/Cargo.toml

@@ -1,33 +0,0 @@
-[workspace]
-members = ["crates/codingest", "crates/codingest-cli", "crates/codingest-mcp", "crates/codingest-py"]
-resolver = "2"
-
-[workspace.package]
-version = "0.1.3"
-edition = "2021"
-rust-version = "1.88"
-license = "MIT"
-repository = "https://github.com/kkollsga/codingest"
-
-[workspace.dependencies]
-base64 = "0.22"
-sha2 = "0.11"
-# kglite engine + MCP server — imported as crates.io libraries. The 0.14.5
-# floor brings generic workspace-graph hooks and generation-safe MCP activation
-# on top of the current deterministic Postcard persistence stack.
-# Keep both libraries aligned so the graph and server share one engine release.
-kglite = { version = "0.14.5", default-features = false }
-kglite-mcp-server = { version = "0.14.5", default-features = false }
-
-# Mirror KGLite's release codegen so the standalone builder has
-# performance parity with the in-tree component (see KGLite
-# workspace Cargo.toml).
-[profile.release]
-lto = "thin"
-codegen-units = 1
-strip = "symbols"
-
-[profile.profiling]
-inherits = "release"
-debug = "line-tables-only"
-strip = "none"