diffctx 1.12.0__tar.gz → 1.12.1__tar.gz

{diffctx-1.12.0 → diffctx-1.12.1}/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Standalone native binaries (linux x86_64/aarch64, macOS arm64, Windows
+  x64) are built and attached to every GitHub release. The README had
+  promised them since 1.9.x; releases only ever carried wheels and an sdist.
+- The Rust engine is published to crates.io as the `diffctx` crate
+  (`cargo install diffctx` for the native CLI, `cargo add diffctx` to embed the
+  selection pipeline). Previously the name held only a reservation stub; the
+  crate now carries the released engine, starting at 1.12.0.
+- Container image `ghcr.io/nikolay-e/diffctx` (linux amd64/arm64), built from
+  the release tag and smoke-tested against a real repository before the tag
+  moves: `docker run --rm -v "$PWD:/repo" ghcr.io/nikolay-e/diffctx . --diff HEAD~1`.
+- Packaging manifests generated from the release checksums: Scoop
+  (`packaging/scoop/diffctx.json`), AUR (`packaging/aur/`) and an npm wrapper
+  (`packaging/npm/`) that downloads the platform binary and verifies its
+  SHA-256 against the published checksum.
+
+### Fixed
+
+- The native binary silently emitted YAML for every unrecognized `--format`,
+  including `md` — the documented default of the Python CLI. It now accepts
+  only `yaml`/`json` and exits 2 on anything else.
+
 ## [1.12.0] - 2026-07-23
 
 ### Added

{diffctx-1.12.0 → diffctx-1.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffctx
-Version: 1.12.0
+Version: 1.12.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -64,6 +64,7 @@ Provides-Extra: tree-sitter
 License-File: LICENSE
 Summary: Export codebase structure and contents for AI/LLM context
 Keywords: ai,chatgpt,claude,code-analysis,code-context,code-review,code-to-prompt,codebase,context,context-selection,diff-context,directory-tree,export,git-diff,json,llm,llm-context,mcp,model-context-protocol,tree,yaml
+Home-Page: https://github.com/nikolay-e/diffctx
 Author-email: Nikolay Eremeev <nikolay.eremeev@outlook.com>
 License-Expression: Apache-2.0
 Requires-Python: >=3.10
@@ -77,6 +78,7 @@ Project-URL: Repository, https://github.com/nikolay-e/diffctx
 
 [![CI](https://github.com/nikolay-e/diffctx/actions/workflows/ci.yml/badge.svg)](https://github.com/nikolay-e/diffctx/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/diffctx)](https://pypi.org/project/diffctx/)
+[![crates.io](https://img.shields.io/crates/v/diffctx)](https://crates.io/crates/diffctx)
 [![License](https://img.shields.io/pypi/l/diffctx)](https://pypi.org/project/diffctx/)
 
 **diffctx selects the minimum code an LLM needs to review a git diff.**
@@ -109,11 +111,23 @@ pip install diffctx                     # or: into an active environment
 pipx install 'diffctx[mcp]'             # + MCP server for AI assistants
 ```
 
-A standalone binary (no Python required) is on the
-[releases page](https://github.com/nikolay-e/diffctx/releases/latest).
 The `[tree-sitter]` extra adds AST-level parsing for more accurate context
 selection across 30+ languages.
 
+Without Python:
+
+```bash
+cargo install diffctx                   # native CLI from crates.io
+docker run --rm -v "$PWD:/repo" ghcr.io/nikolay-e/diffctx . --diff HEAD~1
+```
+
+Prebuilt binaries for linux (x86_64/aarch64), macOS (arm64) and Windows (x64)
+are attached to every [release](https://github.com/nikolay-e/diffctx/releases/latest).
+The native binary covers diff mode with YAML/JSON output; tree mode, Markdown
+output, the `graph` subcommand and the MCP server live in the Python package.
+`cargo add diffctx` embeds the selection pipeline in a Rust project
+([docs.rs](https://docs.rs/diffctx)).
+
 ## Quick start
 
 ```bash

{diffctx-1.12.0 → diffctx-1.12.1}/README.md

@@ -2,6 +2,7 @@
 
 [![CI](https://github.com/nikolay-e/diffctx/actions/workflows/ci.yml/badge.svg)](https://github.com/nikolay-e/diffctx/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/diffctx)](https://pypi.org/project/diffctx/)
+[![crates.io](https://img.shields.io/crates/v/diffctx)](https://crates.io/crates/diffctx)
 [![License](https://img.shields.io/pypi/l/diffctx)](https://pypi.org/project/diffctx/)
 
 **diffctx selects the minimum code an LLM needs to review a git diff.**
@@ -34,11 +35,23 @@ pip install diffctx                     # or: into an active environment
 pipx install 'diffctx[mcp]'             # + MCP server for AI assistants
 ```
 
-A standalone binary (no Python required) is on the
-[releases page](https://github.com/nikolay-e/diffctx/releases/latest).
 The `[tree-sitter]` extra adds AST-level parsing for more accurate context
 selection across 30+ languages.
 
+Without Python:
+
+```bash
+cargo install diffctx                   # native CLI from crates.io
+docker run --rm -v "$PWD:/repo" ghcr.io/nikolay-e/diffctx . --diff HEAD~1
+```
+
+Prebuilt binaries for linux (x86_64/aarch64), macOS (arm64) and Windows (x64)
+are attached to every [release](https://github.com/nikolay-e/diffctx/releases/latest).
+The native binary covers diff mode with YAML/JSON output; tree mode, Markdown
+output, the `graph` subcommand and the MCP server live in the Python package.
+`cargo add diffctx` embeds the selection pipeline in a Rust project
+([docs.rs](https://docs.rs/diffctx)).
+
 ## Quick start
 
 ```bash

{diffctx-1.12.0 → diffctx-1.12.1}/diffctx/Cargo.lock

@@ -194,7 +194,7 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "diffctx"
-version = "1.12.0"
+version = "1.12.1"
 dependencies = [
  "anyhow",
  "clap",

{diffctx-1.12.0 → diffctx-1.12.1}/diffctx/Cargo.toml

@@ -1,8 +1,17 @@
 [package]
 name = "diffctx"
-version = "1.12.0"
+version = "1.12.1"
 edition = "2024"
 rust-version = "1.85"
+description = "Selects the minimum code an LLM needs to review a git diff: walks the dependency graph outward from changed lines and stops when extra context stops paying for itself"
+license = "Apache-2.0"
+repository = "https://github.com/nikolay-e/diffctx"
+homepage = "https://github.com/nikolay-e/diffctx"
+documentation = "https://docs.rs/diffctx"
+readme = "README.md"
+keywords = ["git", "diff", "llm", "context", "tree-sitter"]
+categories = ["development-tools", "command-line-utilities"]
+exclude = ["tests/**", "src/test_harness.rs"]
 
 [lib]
 name = "_diffctx"
@@ -12,10 +21,6 @@ crate-type = ["cdylib", "rlib"]
 name = "diffctx"
 path = "src/main.rs"
 
-[[example]]
-name = "diffctx-test"
-path = "src/test_harness.rs"
-
 [features]
 default = ["lang-core", "lang-extra"]
 python = ["pyo3"]
@@ -127,10 +132,6 @@ pyo3 = { version = "0.29", features = ["extension-module", "abi3-py310"], option
 tempfile = "3"
 libtest-mimic = "0.8"
 
-[[test]]
-name = "yaml_cases"
-harness = false
-
 [lints.clippy]
 pedantic = { level = "warn", priority = -1 }
 nursery = { level = "warn", priority = -1 }

diffctx-1.12.1/diffctx/README.md

@@ -0,0 +1,210 @@
+# diffctx — smart diff context for LLM code review
+
+[![CI](https://github.com/nikolay-e/diffctx/actions/workflows/ci.yml/badge.svg)](https://github.com/nikolay-e/diffctx/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/diffctx)](https://pypi.org/project/diffctx/)
+[![crates.io](https://img.shields.io/crates/v/diffctx)](https://crates.io/crates/diffctx)
+[![License](https://img.shields.io/pypi/l/diffctx)](https://pypi.org/project/diffctx/)
+
+**diffctx selects the minimum code an LLM needs to review a git diff.**
+Instead of pasting whole files, it walks the dependency graph from the changed
+lines outward and stops as soon as additional context stops paying for itself.
+
+> Coming from [`treemapper`](https://pypi.org/project/treemapper/)? That name is
+> deprecated — it was a thin wrapper around diffctx. Every command, flag, and
+> API call works unchanged: `treemapper` → `diffctx`, `treemapper-mcp` → `diffctx-mcp`.
+
+## Why not just use `tree` or repomix?
+
+| | `tree` | repomix | Claude Code Review | **diffctx** |
+|---|:---:|:---:|:---:|:---:|
+| **Primary use case** | directory listing | full repo export | automated PR review | **diff context for code review** |
+| Smart diff context | ✗ | ✗ | ✓ | ✓ |
+| Works with any LLM | ✓ | ✓ | Claude only | ✓ |
+| Free / local / offline | ✓ | ✓ | $15–25/review | ✓ |
+| GitHub required | ✗ | ✗ | ✓ | ✗ |
+| Multiple output formats | ✗ | limited | — | YAML/JSON/MD/txt |
+| Python API | ✗ | ✗ | ✗ | ✓ |
+| MCP server | ✗ | ✗ | ✗ | ✓ |
+
+## Install
+
+```bash
+uvx diffctx . --diff HEAD~1             # zero-install, run once via uv
+pipx install diffctx                    # recommended: isolated CLI, no venv needed
+pip install diffctx                     # or: into an active environment
+pipx install 'diffctx[mcp]'             # + MCP server for AI assistants
+```
+
+The `[tree-sitter]` extra adds AST-level parsing for more accurate context
+selection across 30+ languages.
+
+Without Python:
+
+```bash
+cargo install diffctx                   # native CLI from crates.io
+docker run --rm -v "$PWD:/repo" ghcr.io/nikolay-e/diffctx . --diff HEAD~1
+```
+
+Prebuilt binaries for linux (x86_64/aarch64), macOS (arm64) and Windows (x64)
+are attached to every [release](https://github.com/nikolay-e/diffctx/releases/latest).
+The native binary covers diff mode with YAML/JSON output; tree mode, Markdown
+output, the `graph` subcommand and the MCP server live in the Python package.
+`cargo add diffctx` embeds the selection pipeline in a Rust project
+([docs.rs](https://docs.rs/diffctx)).
+
+## Quick start
+
+```bash
+diffctx . --diff HEAD~1       # smart context for last commit → paste into Claude/ChatGPT
+diffctx . -f md -c            # full codebase export → clipboard in Markdown
+```
+
+![diffctx demo](https://raw.githubusercontent.com/nikolay-e/diffctx/main/docs/demo.gif)
+
+*`diffctx . --diff HEAD~1` selects only the fragments — functions, imports,
+type definitions — that an LLM actually needs to review the last commit,
+instead of dumping every changed file in full.*
+
+## Diff context mode
+
+Finds the minimal set of code fragments needed to understand a change —
+imports, callers, type definitions, config dependencies — across 50+ file
+types. It builds a code graph (imports, co-changes, type refs), propagates
+relevance from the changed lines outward, and stops when relevance drops below
+`--tau` or the `--budget` token cap is reached.
+
+| Flag        | Default | Description                                                              |
+|-------------|---------|--------------------------------------------------------------------------|
+| `--scoring` | `ego`   | `ego` = bounded expansion around changed nodes (fast, predictable radius); `ppr` = Personalized PageRank (global, smoother decay, slower); `bm25` = lexical retrieval against the diff hunks (baseline for sparse graphs) |
+| `--budget`  | auto    | Hard token cap: `N` enforces a fixed cap, `-1` disables it, `0` is a strict-zero floor (empty selection; use `--full` for changed files only) |
+| `--alpha`   | 0.60    | PPR damping; higher = context clusters tighter around changes (`--scoring ppr` only) |
+| `--tau`     | 0.12    | Relevance threshold for full fragment content; lower-scoring fragments are stubbed or dropped (lower = more context) |
+| `--full`    | false   | Only the changed files, every fragment, no related-code context          |
+| `--timeout` | 300     | Wall-clock deadline in seconds; on expiry diffctx exits 124 instead of hanging |
+
+Calibration of `--alpha`, `--tau`, and the edge-weight priors:
+[`docs/parameter-strategy.md`](docs/parameter-strategy.md). Theory:
+[Context-Selection for Git Diff (Zenodo, 2026)](https://doi.org/10.5281/zenodo.18824580).
+
+### `graph` subcommand
+
+Explore the underlying dependency graph directly, without a diff:
+
+```bash
+diffctx graph .                                  # Mermaid graph of directory deps (default)
+diffctx graph . --summary                        # cycles, hotspots, coupling metrics
+diffctx graph . --level fragment -f json         # fragment-level graph as JSON
+diffctx graph . --level file -f graphml -o g.xml # file-level graph as GraphML
+```
+
+## Usage
+
+<!-- BEGIN USAGE -->
+```bash
+# full codebase export:
+diffctx .                                # Markdown to stdout + token count
+diffctx . -f md -c                       # Markdown → clipboard
+diffctx . -f json -o tree.json           # JSON → file
+diffctx . --no-content                   # structure only, no file contents
+diffctx . --max-depth 3                  # limit depth
+diffctx . -i custom.ignore               # custom ignore patterns
+
+# diff context mode (requires git repo):
+diffctx . --diff                         # uncommitted changes (working tree vs HEAD)
+diffctx . --diff HEAD~1                  # context for last commit
+diffctx . --diff main..feature           # context for feature branch
+diffctx . --diff HEAD~1 --budget 30000   # limit to ~30k tokens
+diffctx . --diff HEAD~1 -c               # diff context to clipboard
+```
+<!-- END USAGE -->
+
+Every run reports token count and size on stderr — `12,847 tokens
+(o200k_base), 52.3 KB` (tiktoken, the GPT-4o tokenizer; `~`-prefixed
+approximation above 1 MB). `-c/--copy` sends output to the clipboard via
+`pbcopy` (macOS), `clip` (Windows), or `wl-copy`/`xclip`/`xsel` (Linux).
+Unreadable files are replaced by placeholders such as `<binary file: N bytes>`,
+`<file too large: N bytes>`, or `<unreadable content: not utf-8>`.
+
+## Python API
+
+```python
+from pathlib import Path
+from diffctx import build_diff_context, map_directory, to_json, to_markdown, to_text, to_yaml
+
+ctx = build_diff_context(
+    Path("."),
+    "HEAD~1..HEAD",
+    budget_tokens=None,       # None = auto; 0 = strict-zero floor (empty); -1 = uncapped; N = hard cap
+    alpha=0.6,
+    tau=0.12,
+    full=False,
+    scoring_mode="ego",
+    timeout=300,
+)
+print(to_markdown(ctx))
+
+tree = map_directory(
+    ".",
+    max_depth=None,
+    no_content=False,
+    max_file_bytes=None,
+    ignore_file=None,
+    no_default_ignores=False,
+    whitelist_file=None,
+)
+print(to_yaml(tree))
+```
+
+## MCP server
+
+diffctx includes an [MCP](https://modelcontextprotocol.io) server that lets AI
+assistants (Claude Code, Cursor, Windsurf, etc.) call diff context analysis
+automatically during code review. Install with `pip install 'diffctx[mcp]'`
+and add to your MCP client config (e.g. `~/.claude/mcp.json` for Claude Code):
+
+```json
+{
+  "mcpServers": {
+    "diffctx": {
+      "command": "diffctx-mcp"
+    }
+  }
+}
+```
+
+The server exposes a `get_diff_context` tool that assistants call when
+reviewing PRs, explaining changes, or investigating broken tests. Configs for
+Cursor, Continue, Windsurf, and Zed:
+[`src/diffctx/mcp/README.md`](src/diffctx/mcp/README.md).
+
+## Ignore patterns
+
+Respects `.gitignore` and `.diffctx/ignore` automatically — hierarchically at
+every directory level, with gitignore semantics (negation `!important.log`,
+anchored `/root_only.txt`). `.diffctx/whitelist` acts as an include-only
+filter, and the output file is always auto-ignored. `--no-default-ignores`
+disables the built-in patterns; `--no-ignores` disables all ignore rules
+(tree mode only).
+
+## Exit codes
+
+| Code | Meaning |
+|------|---------|
+| `0`  | Success — output contains content |
+| `1`  | Runtime error (bad path, permission denied, etc.) |
+| `2`  | Usage error (invalid flags/arguments) |
+| `3`  | Environment error (`--diff` outside a git repo, git not installed, no commits yet) |
+| `4`  | `--diff` produced no semantic context (clean tree, binary-only, everything filtered); output is still emitted. Deletion/rename-only diffs list `deleted_files`/`renamed_files` and exit `0` |
+| `130`| Interrupted (Ctrl-C) |
+| `141`| Broken pipe (e.g. piping into `head`) |
+
+## License
+
+Apache 2.0
+
+---
+
+- [Changelog](CHANGELOG.md)
+- [Security policy](SECURITY.md) — threat model and vulnerability reporting
+- [Parameter strategy](docs/parameter-strategy.md) — how `--alpha`,
+  `--tau`, and edge weights are calibrated

{diffctx-1.12.0 → diffctx-1.12.1}/diffctx/src/main.rs

@@ -27,7 +27,7 @@ struct Cli {
     #[arg(long, default_value_t = DEFAULT_BUDGET_TOKENS)]
     budget: u32,
 
-    #[arg(long, default_value = "yaml")]
+    #[arg(long, default_value = "yaml", value_parser = ["yaml", "json"])]
     format: String,
 
     #[arg(long = "diff")]
@@ -113,10 +113,13 @@ fn main() -> Result<()> {
             let json = serde_json::to_string_pretty(&output)?;
             println!("{}", json);
         }
-        _ => {
+        "yaml" => {
             let yaml = serde_yaml::to_string(&output)?;
             print!("{}", yaml);
         }
+        other => {
+            anyhow::bail!("diffctx: unsupported --format '{other}' (native binary: yaml, json)")
+        }
     }
 
     Ok(())

{diffctx-1.12.0 → diffctx-1.12.1}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "maturin>=1.10,<1.15" ]
 
 [project]
 name = "diffctx"
-version = "1.12.0"
+version = "1.12.1"
 description = "Export codebase structure and contents for AI/LLM context"
 readme = "README.md"
 keywords = [

diffctx-1.12.1/src/diffctx/version.py

@@ -0,0 +1 @@
+__version__ = "1.12.1"

diffctx-1.12.0/diffctx/tests/common/mod.rs

@@ -1,274 +0,0 @@
-use std::collections::BTreeMap;
-use std::path::Path;
-use std::sync::OnceLock;
-
-use serde::Deserialize;
-
-use _diffctx::render::{DiffContextOutput, FragmentEntry};
-
-#[derive(Debug, Deserialize, Clone, Default)]
-pub struct TestCase {
-    #[serde(default)]
-    pub name: String,
-    #[serde(default)]
-    pub tags: Vec<String>,
-    #[serde(default)]
-    pub repo: Repo,
-    #[serde(default)]
-    pub fixtures: Fixtures,
-    #[serde(default)]
-    pub fragments: Vec<DeclaredFragment>,
-    #[serde(default)]
-    pub oracle: Oracle,
-    #[serde(default)]
-    pub accept: Accept,
-    #[serde(default)]
-    pub xfail: Option<XFail>,
-    #[serde(default)]
-    pub min_score: Option<f64>,
-}
-
-#[derive(Debug, Deserialize, Clone, Default)]
-pub struct Repo {
-    #[serde(default)]
-    pub initial_files: BTreeMap<String, String>,
-    #[serde(default)]
-    pub changed_files: BTreeMap<String, String>,
-    #[serde(default = "default_commit_message")]
-    pub commit_message: String,
-}
-
-#[derive(Debug, Deserialize, Clone, Default)]
-pub struct Fixtures {
-    #[serde(default)]
-    pub auto_garbage: bool,
-    #[serde(default)]
-    pub distractors: BTreeMap<String, String>,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct DeclaredFragment {
-    pub id: String,
-    #[serde(default)]
-    pub selector: Selector,
-}
-
-#[derive(Debug, Deserialize, Clone, Default)]
-pub struct Selector {
-    pub path: Option<String>,
-    pub symbol: Option<String>,
-    pub kind: Option<String>,
-    pub anchor: Option<String>,
-    pub any_of: Option<Vec<Selector>>,
-}
-
-#[derive(Debug, Deserialize, Clone, Default)]
-pub struct Oracle {
-    #[serde(default)]
-    pub required: Vec<String>,
-    #[serde(default)]
-    pub allowed: Vec<String>,
-    #[serde(default)]
-    pub forbidden: Vec<String>,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct Accept {
-    #[serde(default = "default_symbol_match")]
-    pub symbol_match: String,
-    #[serde(default)]
-    pub kind_must_match: bool,
-    #[serde(default = "default_span_relation")]
-    pub span_relation: String,
-}
-
-impl Default for Accept {
-    fn default() -> Self {
-        Self {
-            symbol_match: default_symbol_match(),
-            kind_must_match: false,
-            span_relation: default_span_relation(),
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct XFail {
-    #[serde(default)]
-    pub category: Option<String>,
-    #[serde(default)]
-    pub reason: Option<String>,
-    #[serde(default)]
-    pub issue: Option<String>,
-}
-
-impl XFail {
-    pub fn is_active(&self) -> bool {
-        self.reason.is_some() || self.category.is_some()
-    }
-}
-
-fn default_symbol_match() -> String {
-    "exact".into()
-}
-fn default_span_relation() -> String {
-    "exact_or_enclosing".into()
-}
-fn default_commit_message() -> String {
-    "Update files".into()
-}
-
-pub fn match_path(candidate: &str, target: &str) -> bool {
-    candidate == target
-        || candidate.ends_with(&format!("/{target}"))
-        || candidate
-            .replace('\\', "/")
-            .ends_with(&format!("/{target}"))
-}
-
-pub fn symbol_matches(frag_symbol: &str, expected: &str, mode: &str) -> bool {
-    match mode {
-        "prefix" => frag_symbol.starts_with(expected),
-        "substring" => frag_symbol.contains(expected),
-        _ => frag_symbol == expected,
-    }
-}
-
-pub fn matches_selector(fragment: &FragmentEntry, selector: &Selector, accept: &Accept) -> bool {
-    if let Some(any) = &selector.any_of {
-        return any.iter().any(|s| matches_selector(fragment, s, accept));
-    }
-    if let Some(path) = &selector.path {
-        if !match_path(&fragment.path, path) {
-            return false;
-        }
-    }
-    if let Some(symbol) = &selector.symbol {
-        let frag_symbol = fragment.symbol.as_deref().unwrap_or("");
-        if !symbol_matches(frag_symbol, symbol, &accept.symbol_match) {
-            return false;
-        }
-    }
-    if let Some(kind) = &selector.kind {
-        if accept.kind_must_match && fragment.kind != *kind {
-            return false;
-        }
-    }
-    if let Some(anchor) = &selector.anchor {
-        let content = fragment.content.as_deref().unwrap_or("");
-        if !content.contains(anchor) && !fragment.path.contains(anchor) {
-            return false;
-        }
-    }
-    true
-}
-
-pub struct OracleResult {
-    pub passed: bool,
-    pub score: f64,
-    pub recall: f64,
-    pub forbidden_rate: f64,
-    pub missing_required: Vec<String>,
-    pub hit_forbidden: Vec<String>,
-}
-
-pub fn evaluate_oracle(case: &TestCase, output: &DiffContextOutput) -> OracleResult {
-    let mut matched_ids: std::collections::HashSet<&str> = std::collections::HashSet::new();
-    for entry in &output.fragments {
-        for decl in &case.fragments {
-            if matches_selector(entry, &decl.selector, &case.accept) {
-                matched_ids.insert(decl.id.as_str());
-            }
-        }
-    }
-
-    let required_total = case.oracle.required.len();
-    let missing_required: Vec<String> = case
-        .oracle
-        .required
-        .iter()
-        .filter(|id| !matched_ids.contains(id.as_str()))
-        .cloned()
-        .collect();
-
-    let forbidden_total = case.oracle.forbidden.len();
-    let hit_forbidden: Vec<String> = case
-        .oracle
-        .forbidden
-        .iter()
-        .filter(|id| matched_ids.contains(id.as_str()))
-        .cloned()
-        .collect();
-
-    let recall = if required_total == 0 {
-        1.0
-    } else {
-        (required_total - missing_required.len()) as f64 / required_total as f64
-    };
-    let forbidden_rate = if forbidden_total == 0 {
-        0.0
-    } else {
-        hit_forbidden.len() as f64 / forbidden_total as f64
-    };
-    let score = 100.0 * recall * (1.0 - forbidden_rate);
-    let passed = missing_required.is_empty() && hit_forbidden.is_empty();
-
-    OracleResult {
-        passed,
-        score,
-        recall,
-        forbidden_rate,
-        missing_required,
-        hit_forbidden,
-    }
-}
-
-pub fn calculate_budget(case: &TestCase) -> u32 {
-    let overhead = _diffctx::config::limits::LIMITS.overhead_per_fragment;
-    let mut all_files: BTreeMap<String, String> = case.repo.initial_files.clone();
-    for (k, v) in &case.repo.changed_files {
-        all_files.insert(k.clone(), v.clone());
-    }
-    for (k, v) in &case.fixtures.distractors {
-        all_files.insert(k.clone(), v.clone());
-    }
-
-    let content_tokens: u32 = all_files
-        .values()
-        .map(|c| _diffctx::tokenizer::count_tokens(c))
-        .sum();
-    let n_frags = all_files.len().max(2) as u32;
-    ((content_tokens + n_frags * overhead) * 5 / 2).max(500)
-}
-
-static GARBAGE_CACHE: OnceLock<BTreeMap<String, String>> = OnceLock::new();
-
-pub fn garbage_files() -> &'static BTreeMap<String, String> {
-    GARBAGE_CACHE.get_or_init(|| {
-        let mut m = BTreeMap::new();
-        let dir = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("tests")
-            .join("fixtures")
-            .join("garbage");
-        let entries = match std::fs::read_dir(&dir) {
-            Ok(e) => e,
-            Err(_) => return m,
-        };
-        for entry in entries.flatten() {
-            let path = entry.path();
-            if !path.is_file() {
-                continue;
-            }
-            let name = match path.file_name().and_then(|n| n.to_str()) {
-                Some(n) => n,
-                None => continue,
-            };
-            let content = match std::fs::read_to_string(&path) {
-                Ok(c) => c,
-                Err(_) => continue,
-            };
-            m.insert(format!("unrelated_dir/{name}"), content);
-        }
-        m
-    })
-}