diffctx 1.10.0__tar.gz → 1.10.2__tar.gz

{diffctx-1.10.0 → diffctx-1.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffctx
-Version: 1.10.0
+Version: 1.10.2
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{diffctx-1.10.0 → diffctx-1.10.2}/diffctx/Cargo.lock

@@ -355,12 +355,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "hermit-abi"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
-
 [[package]]
 name = "id-arena"
 version = "2.3.0"
@@ -411,23 +405,23 @@ checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
 
 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.47"
+version = "0.1.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d1eacfa31c33ec25e873c136ba5669f00f9866d0688bea7be4d3f7e43067df6"
+checksum = "6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "libtest-mimic"
-version = "0.7.3"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc0bda45ed5b3a2904262c1bb91e526127aa70e7ef3758aba2ef93cf896b9b58"
+checksum = "14e6ba06f0ade6e504aff834d7c34298e5155c6baca353cc6a4aaff2f9fd7f33"
 dependencies = [
+ "anstream",
+ "anstyle",
  "clap",
  "escape8259",
- "termcolor",
- "threadpool",
 ]
 
 [[package]]
@@ -459,9 +453,9 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "mimalloc"
-version = "0.1.50"
+version = "0.1.52"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3627c4272df786b9260cabaa46aec1d59c93ede723d4c3ef646c503816b0640"
+checksum = "2d4139bb28d14ad1facf21d5eb8825051b326e172d216b39f6d31df53cc97862"
 dependencies = [
  "libmimalloc-sys",
 ]
@@ -475,16 +469,6 @@ dependencies = [
  "windows-sys",
 ]
 
-[[package]]
-name = "num_cpus"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
-dependencies = [
- "hermit-abi",
- "libc",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -622,9 +606,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.12.3"
+version = "1.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+checksum = "f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -645,9 +629,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.10"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rustc-hash"
@@ -721,9 +705,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.149"
+version = "1.0.150"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
 dependencies = [
  "indexmap",
  "itoa",
@@ -772,9 +756,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.15.1"
+version = "1.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
 
 [[package]]
 name = "streaming-iterator"
@@ -818,15 +802,6 @@ dependencies = [
  "windows-sys",
 ]
 
-[[package]]
-name = "termcolor"
-version = "1.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
-dependencies = [
- "winapi-util",
-]
-
 [[package]]
 name = "thiserror"
 version = "2.0.18"
@@ -856,15 +831,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "threadpool"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
-dependencies = [
- "num_cpus",
-]
-
 [[package]]
 name = "tiktoken-rs"
 version = "0.12.0"
@@ -1058,9 +1024,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-go"
-version = "0.23.4"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b13d476345220dbe600147dd444165c5791bf85ef53e28acbedd46112ee18431"
+checksum = "c8560a4d2f835cc0d4d2c2e03cbd0dde2f6114b43bc491164238d333e28b16ea"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -1244,9 +1210,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-r"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "429133cbda9f8a46e03ef3aae6abb6c3d22875f8585cad472138101bfd517255"
+checksum = "ffc9954ec870dcad6cffdd302b405306c68cf031ed79a78cd9746f6740d9fe20"
 dependencies = [
  "cc",
  "tree-sitter-language",
@@ -1264,9 +1230,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter-rust"
-version = "0.23.3"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca8ccb3e3a3495c8a943f6c3fd24c3804c471fd7f4f16087623c7fa4c0068e8a"
+checksum = "439e577dbe07423ec2582ac62c7531120dbfccfa6e5f92406f93dd271a120e45"
 dependencies = [
  "cc",
  "tree-sitter-language",

{diffctx-1.10.0 → diffctx-1.10.2}/diffctx/Cargo.toml

@@ -70,8 +70,8 @@ tree-sitter = "0.25"
 tree-sitter-python = { version = "0.23", optional = true }
 tree-sitter-javascript = { version = "0.23", optional = true }
 tree-sitter-typescript = { version = "0.23", optional = true }
-tree-sitter-go = { version = "0.23", optional = true }
-tree-sitter-rust = { version = "0.23", optional = true }
+tree-sitter-go = { version = "0.25", optional = true }
+tree-sitter-rust = { version = "0.24", optional = true }
 tree-sitter-java = { version = "0.23", optional = true }
 tree-sitter-c = { version = "0.24", optional = true }
 tree-sitter-cpp = { version = "0.23", optional = true }
@@ -126,7 +126,7 @@ pyo3 = { version = "0.29", features = ["extension-module", "abi3-py310"], option
 [dev-dependencies]
 tempfile = "3"
 serde_yaml = "0.9"
-libtest-mimic = "0.7"
+libtest-mimic = "0.8"
 
 [[test]]
 name = "yaml_cases"

{diffctx-1.10.0 → diffctx-1.10.2}/diffctx/src/git.rs

@@ -500,6 +500,135 @@ pub fn get_untracked_files(repo_root: &Path) -> Result<Vec<PathBuf>> {
         .collect())
 }
 
+/// Rewrites one `.diffctx/ignore` pattern line to be anchored to the
+/// directory that contains the `.diffctx/` folder (`rel`, repo-root-relative,
+/// "" for the repo root itself). Mirrors `_process_ignore_line` in the
+/// Python tree-mode ignore resolver (`src/diffctx/ignore.py`) so a pattern
+/// declared in `sub/.diffctx/ignore` only ever matches within `sub/`.
+fn anchor_diffctx_ignore_line(line: &str, rel: &str) -> String {
+    let (neg, pat) = match line.strip_prefix('!') {
+        Some(rest) => (true, rest),
+        None => (false, line),
+    };
+    let pat_no_trailing_slash = pat.trim_end_matches('/');
+    let full = if pat_no_trailing_slash.starts_with('/') || pat_no_trailing_slash.contains('/') {
+        let anchored = pat.trim_start_matches('/');
+        if rel.is_empty() {
+            format!("/{anchored}")
+        } else {
+            format!("/{rel}/{anchored}")
+        }
+    } else if rel.is_empty() {
+        pat.to_string()
+    } else {
+        format!("{rel}/**/{pat}")
+    };
+    if neg { format!("!{full}") } else { full }
+}
+
+/// Finds every `.diffctx/ignore` file tracked or present in `repo_root`
+/// (any depth) and returns its patterns rewritten to be repo-root-relative,
+/// ready to feed into a combined gitignore-syntax exclude file.
+fn collect_diffctx_ignore_patterns(repo_root: &Path) -> Vec<String> {
+    let Ok(files) = run_git_z(
+        repo_root,
+        &[
+            "ls-files",
+            "-z",
+            "--cached",
+            "--others",
+            "--exclude-standard",
+            "--",
+            ":(glob)**/.diffctx/ignore",
+        ],
+    ) else {
+        return Vec::new();
+    };
+
+    let mut patterns = Vec::new();
+    for raw in &files {
+        let rel_path = unquote_c_style(raw);
+        if !rel_path.ends_with(".diffctx/ignore") {
+            continue;
+        }
+        let rel_dir = rel_path
+            .strip_suffix(".diffctx/ignore")
+            .unwrap_or("")
+            .trim_end_matches('/');
+        let Ok(content) = std::fs::read_to_string(repo_root.join(&rel_path)) else {
+            continue;
+        };
+        for line in content.lines() {
+            let line = line.trim_end();
+            if line.is_empty() || line.starts_with('#') {
+                continue;
+            }
+            patterns.push(anchor_diffctx_ignore_line(line, rel_dir));
+        }
+    }
+    patterns
+}
+
+/// Returns the subset of `rel_paths` (repo-root-relative) excluded by either
+/// `.gitignore` (via git's own engine, so nesting/negation/`**` are handled
+/// correctly) or `.diffctx/ignore` (patterns anchored per-directory and fed
+/// to git as a temporary `core.excludesFile`, so the same engine evaluates
+/// both mechanisms uniformly). Best-effort: any failure returns an empty set
+/// rather than blocking the diff pipeline on an ignore-resolution problem.
+pub fn find_ignored_paths(repo_root: &Path, rel_paths: &[String]) -> FxHashSet<String> {
+    if rel_paths.is_empty() {
+        return FxHashSet::default();
+    }
+
+    let diffctx_patterns = collect_diffctx_ignore_patterns(repo_root);
+    let temp_excludes = if diffctx_patterns.is_empty() {
+        None
+    } else {
+        let path = std::env::temp_dir().join(format!("diffctx-ignore-{}.tmp", std::process::id()));
+        match std::fs::write(&path, diffctx_patterns.join("\n")) {
+            Ok(()) => Some(path),
+            Err(_) => None,
+        }
+    };
+
+    let mut args: Vec<String> = vec!["check-ignore".into(), "--no-index".into()];
+    if let Some(ref path) = temp_excludes {
+        args.insert(0, format!("core.excludesFile={}", path.display()));
+        args.insert(0, "-c".into());
+    }
+    args.push("--".into());
+    args.extend(rel_paths.iter().cloned());
+    let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();
+
+    let result = (|| -> Result<FxHashSet<String>> {
+        let mut cmd = Command::new("git");
+        cmd.arg("-C")
+            .arg(repo_root)
+            .args(&arg_refs)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+        let child = cmd.spawn()?;
+        let output = wait_with_timeout(child, Duration::from_secs(git_timeout()), &arg_refs)?;
+        // Exit code 1 from `check-ignore` means "none of the given paths are
+        // ignored" — not a failure. Any other non-zero code is a real error.
+        if !output.status.success() && output.status.code() != Some(1) {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return Err(GitError::CommandFailed(format!(
+                "git check-ignore failed: {}",
+                stderr.trim()
+            )));
+        }
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        Ok(stdout.lines().map(unquote_c_style).collect())
+    })();
+
+    if let Some(path) = temp_excludes {
+        let _ = std::fs::remove_file(path);
+    }
+
+    result.unwrap_or_default()
+}
+
 pub struct CatFileBatch {
     repo_root: PathBuf,
     child: Option<Child>,

{diffctx-1.10.0 → diffctx-1.10.2}/diffctx/src/main.rs

@@ -3,6 +3,9 @@ use mimalloc::MiMalloc;
 static GLOBAL: MiMalloc = MiMalloc;
 
 use std::path::PathBuf;
+use std::sync::mpsc;
+use std::thread;
+use std::time::Duration;
 
 use anyhow::Result;
 use clap::Parser;
@@ -60,17 +63,50 @@ fn main() -> Result<()> {
         eprintln!("error: {e}");
         std::process::exit(2);
     });
-    let output = build_diff_context(
-        &cli.path,
-        cli.diff_ref.as_deref(),
-        Some(cli.budget),
-        cli.alpha,
-        cli.tau,
-        cli.no_content,
-        cli.full,
-        scoring_mode,
-        cli.timeout,
-    )?;
+
+    // The per-phase git timeout does not bound in-process phases (parse, graph
+    // build, scoring), so a pathological repo can hang far past `--timeout`
+    // until OOM/SIGKILL (#70). Run the pipeline on a worker thread and enforce
+    // `--timeout` as a true total wall-clock ceiling: on expiry, fail fast with
+    // the actionable-error contract instead of hanging unbounded.
+    let timeout = cli.timeout;
+    let path = cli.path.clone();
+    let diff_ref = cli.diff_ref.clone();
+    let budget = cli.budget;
+    let alpha = cli.alpha;
+    let tau = cli.tau;
+    let no_content = cli.no_content;
+    let full = cli.full;
+    let (tx, rx) = mpsc::channel();
+    thread::spawn(move || {
+        let result = build_diff_context(
+            &path,
+            diff_ref.as_deref(),
+            Some(budget),
+            alpha,
+            tau,
+            no_content,
+            full,
+            scoring_mode,
+            timeout,
+        );
+        let _ = tx.send(result);
+    });
+
+    let output = match rx.recv_timeout(Duration::from_secs(timeout)) {
+        Ok(result) => result?,
+        Err(mpsc::RecvTimeoutError::Timeout) => {
+            eprintln!(
+                "diffctx: pipeline exceeded {timeout}s wall-clock deadline; aborting before \
+                 OOM/SIGKILL. Narrow the review with an explicit '--diff <from>..<to>' range or \
+                 run on a smaller subtree, or raise '--timeout'."
+            );
+            std::process::exit(124);
+        }
+        Err(mpsc::RecvTimeoutError::Disconnected) => {
+            anyhow::bail!("diffctx: pipeline worker terminated unexpectedly");
+        }
+    };
 
     match cli.format.as_str() {
         "json" => {

{diffctx-1.10.0 → diffctx-1.10.2}/diffctx/src/memory_pipeline.rs

@@ -162,6 +162,7 @@ pub fn build_diff_context_in_memory(
         Path::new("."),
         &[],
         None,
+        &core_ids,
     );
 
     let dummy_root = Path::new(".");

{diffctx-1.10.0 → diffctx-1.10.2}/diffctx/src/parsers/markdown.rs

@@ -54,8 +54,8 @@ impl FragmentationStrategy for MarkdownStrategy {
         let total_lines = lines.len() as u32;
         let mut fragments: Vec<Fragment> = Vec::new();
 
-        for (idx, &(start_line, level, _)) in headings.iter().enumerate() {
-            let end_line = find_section_end(&headings, idx, level, total_lines);
+        for (idx, &(start_line, _level, _)) in headings.iter().enumerate() {
+            let end_line = find_section_end(&headings, idx, total_lines);
             if end_line < start_line {
                 continue;
             }
@@ -90,16 +90,57 @@ impl FragmentationStrategy for MarkdownStrategy {
     }
 }
 
-fn find_section_end(
-    headings: &[(u32, u32, String)],
-    idx: usize,
-    level: u32,
-    total_lines: u32,
-) -> u32 {
-    for &(next_line, next_level, _) in &headings[idx + 1..] {
-        if next_level <= level {
-            return next_line - 1;
-        }
+/// A heading's own fragment ends at the very next heading, regardless of
+/// level — not at the next heading of the *same or higher* level. The old
+/// same-or-higher rule made a heading's span include every nested
+/// subsection beneath it, so a lone top-level `#` heading (the common case:
+/// one H1 title, many `##`/`###` children) spanned the entire rest of the
+/// document. A one-line change in the H1's own preamble then flagged that
+/// all-encompassing fragment as `role: "changed"`, dumping the whole file
+/// instead of just the touched paragraph (#91).
+fn find_section_end(headings: &[(u32, u32, String)], idx: usize, total_lines: u32) -> u32 {
+    match headings.get(idx + 1) {
+        Some(&(next_line, _, _)) => next_line - 1,
+        None => total_lines,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Regression for #91: a lone H1 title followed only by `##` children
+    /// must not produce a single fragment spanning the whole document — the
+    /// H1's own fragment is just its direct preamble, up to the first child.
+    #[test]
+    fn h1_fragment_stops_at_first_child_heading_not_eof() {
+        let content =
+            "# Title\n\nPreamble line.\n\n## Section One\nBody one.\n\n## Section Two\nBody two.\n";
+        let fragments = MarkdownStrategy.fragment(Arc::from("doc.md"), content);
+
+        let title = fragments
+            .iter()
+            .find(|f| f.content.starts_with("# Title"))
+            .expect("Title fragment present");
+        assert_eq!(title.id.start_line, 1);
+        assert_eq!(
+            title.id.end_line, 4,
+            "H1 fragment should stop before '## Section One', not run to EOF"
+        );
+    }
+
+    #[test]
+    fn sibling_headings_still_each_get_their_own_fragment() {
+        let content =
+            "## Section One\nBody one.\n\n## Section Two\nBody two.\n### Nested\nNested body.\n";
+        let fragments = MarkdownStrategy.fragment(Arc::from("doc.md"), content);
+        assert_eq!(fragments.len(), 3);
+
+        let nested = fragments
+            .iter()
+            .find(|f| f.content.starts_with("### Nested"))
+            .expect("Nested fragment present");
+        assert_eq!(nested.id.start_line, 6);
+        assert_eq!(nested.id.end_line, 8);
     }
-    total_lines
 }

{diffctx-1.10.0 → diffctx-1.10.2}/diffctx/src/pipeline.rs

@@ -131,6 +131,13 @@ pub fn compute_scored_state(
         return Ok(empty_scored_state(root_dir));
     }
 
+    let ignored_rel_paths = resolve_ignored_paths(&root_dir, &hunks);
+    hunks.retain(|h| !is_ignored_path(&root_dir, Path::new(&*h.path), &ignored_rel_paths));
+
+    if hunks.is_empty() {
+        return Ok(empty_scored_state(root_dir));
+    }
+
     let diff_text = git::get_diff_text(&root_dir, diff_range)?;
 
     let mut changed_files = git::get_changed_files(&root_dir, diff_range)?;
@@ -152,7 +159,9 @@ pub fn compute_scored_state(
         .into_iter()
         .filter(|f| {
             let resolved = f.canonicalize().unwrap_or_else(|_| f.clone());
-            !excluded.contains(&resolved) && !is_secret_path(f)
+            !excluded.contains(&resolved)
+                && !is_secret_path(f)
+                && !is_ignored_path(&root_dir, f, &ignored_rel_paths)
         })
         .collect();
 
@@ -412,6 +421,7 @@ pub fn select_with_params(
         &state.root_dir,
         &state.preferred_revs,
         batch_reader.as_mut(),
+        &state.core_ids,
     );
     if let Some(mut r) = batch_reader {
         r.close();
@@ -493,6 +503,31 @@ fn is_secret_path(path: &Path) -> bool {
     )
 }
 
+fn rel_path_string(root_dir: &Path, path: &Path) -> Option<String> {
+    path.strip_prefix(root_dir)
+        .ok()
+        .map(|p| p.to_string_lossy().replace('\\', "/"))
+}
+
+/// Resolves `.gitignore` / `.diffctx/ignore` exclusions (#85) for every path
+/// touched by `hunks`, in one batched git call. diff mode previously only
+/// ever excluded a hardcoded set of secret-like filenames (`is_secret_path`)
+/// — a file a user explicitly excluded via `.diffctx/ignore` still had its
+/// changed content surfaced in full.
+fn resolve_ignored_paths(root_dir: &Path, hunks: &[crate::types::DiffHunk]) -> FxHashSet<String> {
+    let rel_paths: Vec<String> = hunks
+        .iter()
+        .filter_map(|h| rel_path_string(root_dir, Path::new(&*h.path)))
+        .collect();
+    git::find_ignored_paths(root_dir, &rel_paths)
+}
+
+fn is_ignored_path(root_dir: &Path, path: &Path, ignored_rel_paths: &FxHashSet<String>) -> bool {
+    rel_path_string(root_dir, path)
+        .map(|rel| ignored_rel_paths.contains(&rel))
+        .unwrap_or(false)
+}
+
 fn build_diff_context_full(
     root_dir: &Path,
     diff_range: Option<&str>,
@@ -512,8 +547,14 @@ fn build_diff_context_full(
     if hunks.is_empty() {
         return Ok(empty_output(&root_dir));
     }
+    let ignored_rel_paths = resolve_ignored_paths(&root_dir, &hunks);
+    hunks.retain(|h| !is_ignored_path(&root_dir, Path::new(&*h.path), &ignored_rel_paths));
+    if hunks.is_empty() {
+        return Ok(empty_output(&root_dir));
+    }
     let mut changed_files = git::get_changed_files(&root_dir, diff_range)?;
-    changed_files.retain(|f| !is_secret_path(f));
+    changed_files
+        .retain(|f| !is_secret_path(f) && !is_ignored_path(&root_dir, f, &ignored_rel_paths));
     if changed_files.is_empty() {
         return Ok(empty_output(&root_dir));
     }