diffctx 1.19.0__tar.gz → 1.19.1__tar.gz

{diffctx-1.19.0 → diffctx-1.19.1}/CHANGELOG.md

@@ -7,6 +7,85 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.19.1] - 2026-10-14
+
+### Added
+
+- Go callers come from syntax facts: a package is its directory, an import
+  binds it by the path `go.mod` gives it, an alias or a dot import names it,
+  an unexported name never leaves its package, and a method call resolves
+  when the syntax states the value's type (a receiver, a parameter,
+  `x := &pkg.T{}`). A same-named function of another package, a struct
+  field, a local and a string are no longer callers (#506).
+
+### Fixed
+
+- Module-level calls are listed beside a function-level caller in the same
+  file (#449), and a caller split into chunks spans every call site (#472).
+- A call inside a function's local `const` names the function as the caller,
+  with its test link, not the local (#452).
+- `async function` and generator functions are JS/TS definitions: a call
+  from the same file read as "nothing calls them" (#481).
+- Shell functions are called from their own script's body and from scripts
+  that source them; a script calling its own `run_tool` read as no caller
+  (#497).
+- Callers of a removed definition keep their test links; a removed `pub fn`
+  of a private Rust module or a binary is no removed API; possible callers
+  are shed before contracts, and the header counts every caller found and
+  every one without a test link at any budget (#413).
+- `--full` reads under the run's deadline and names it, instead of exiting
+  with "files over the size cap" when a git read stalls (#439).
+- A tree the hook builds from the session's edits is "the snapshot tree",
+  not "staged changes"; prose beside migrations is no schema contract; the
+  hook asks to check callers only when it lists some (#463).
+- `selftest*` files are tests (#428).
+- Deleting a module of tens of thousands of definitions no longer overflows
+  the argument list of the name search: the names go to `git grep` through a
+  pattern file, and the callers are found instead of a failed read (#440).
+- The search hook reads `git grep PATTERN REV -- PATH`'s revision as one,
+  not as a directory outside any repository (#486), and a qualified search
+  word (`tests.direct`) searches for its last name, not its qualifier
+  (#402).
+- A line the change itself wrote about a deletion (a changelog entry, a
+  comment) is no stale reference, and a path that ends a sentence still is
+  one (#456).
+- A private Rust function removed in favour of an imported shared one has
+  no callers: a private item is reachable only from its own module and the
+  modules beneath it, a `use` from another module binds a file's calls
+  there, and a `use` line is no reference (#519).
+- The search hook answers a pattern branch only when it names exactly one
+  identifier: a grep for a line of code is no search for each of its words
+  (#402).
+- A changed constructor (`__init__`, `constructor`) is called by its
+  class's name: `cp.Model(…)`, `Model(…)` and `new Store(…)` are its callers
+  (#318).
+- JS/TS class methods, object-literal methods and a store's actions built
+  inside `create(...)` are definitions with callers — through `this`, a typed
+  instance, the object, or possibly any receiver (#444, #473); a call wrapped
+  in parentheses at module level is a caller, and a call inside an anonymous
+  arrow belongs to the definition around it (#520); a component reached
+  through `lazy(() => import(…))` or `await import(…)` is referenced there
+  (#479); a workspace package's specifier (`@scope/core`) resolves into its
+  source (#474).
+- Python: a pytest fixture is called by the tests and fixtures that take it
+  as a parameter (#401); an `Any` receiver and an object from a factory
+  classmethod are possible callers (#425).
+- Java: a method calling a sibling of its own class with no qualifier is a
+  caller (#496). Rust: a local closure named like a changed function is no
+  caller of it (#391).
+- A file over the size cap that names a changed definition is said as a
+  place callers may be missing, instead of the answer reading complete
+  (#484); a file of another runtime that breaks its parse is no such hedge
+  (#521).
+- A hand-written "do not edit" header no longer marks a file generated;
+  a generator's header still does (#411).
+- The native CLI refuses `--symbol` with another `--mode` named outright,
+  reads `PATH` in `--symbol PATH:NAME` from the path it was given, and parses
+  the watchdog override as the Python CLI does (#410).
+- A file that declares a removed definition's name itself calls its own,
+  not the removed one: deleting a private `declared_name` in one Rust file
+  listed another file's calls to its own `declared_name` as broken callers.
+
 ## [1.19.0] - 2026-10-14
 
 ### Added
@@ -2299,7 +2378,8 @@ Earlier releases shipped as `treemapper`; see
 <https://github.com/nikolay-e/diffctx/releases> for the corresponding GitHub
 release notes (`1.0.0` through `1.6.1`).
 
-[Unreleased]: https://github.com/nikolay-e/diffctx/compare/v1.19.0...HEAD
+[Unreleased]: https://github.com/nikolay-e/diffctx/compare/v1.19.1...HEAD
+[1.19.1]: https://github.com/nikolay-e/diffctx/compare/v1.19.0...v1.19.1
 [1.19.0]: https://github.com/nikolay-e/diffctx/compare/v1.18.4...v1.19.0
 [1.18.4]: https://github.com/nikolay-e/diffctx/compare/v1.18.3...v1.18.4
 [1.18.3]: https://github.com/nikolay-e/diffctx/compare/v1.18.2...v1.18.3

{diffctx-1.19.0 → diffctx-1.19.1}/Cargo.lock

@@ -204,7 +204,7 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "diffctx"
-version = "1.19.0"
+version = "1.19.1"
 dependencies = [
  "aho-corasick",
  "anyhow",

{diffctx-1.19.0 → diffctx-1.19.1}/PKG-INFO

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

{diffctx-1.19.0 → diffctx-1.19.1}/crates/diffctx-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "diffctx"
-version = "1.19.0"
+version = "1.19.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"

{diffctx-1.19.0 → diffctx-1.19.1}/crates/diffctx-native/src/bindings.rs

@@ -154,7 +154,7 @@ static JS_EXPORT_FROM: Lazy<Regex> = Lazy::new(|| {
 });
 static JS_REQUIRE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
-        r#"(?s)\b(?:const|let|var)\s+(\{[^}]*\}|[\w$]+)\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)"#,
+        r#"(?s)\b(?:const|let|var)\s+(\{[^}]*\}|[\w$]+)\s*=\s*(?:require|await\s+import)\(\s*['"]([^'"]+)['"]\s*\)"#,
     )
     .unwrap()
 });
@@ -188,6 +188,15 @@ fn is_ident(s: &str) -> bool {
         && !s.starts_with(|c: char| c.is_ascii_digit())
 }
 
+/// `import('./x').then(m => …)`, `.then((m) => …)`, `.then(function (m)`:
+/// the callback's parameter is the module (#479, `React.lazy`).
+static JS_DYNAMIC_THEN: Lazy<Regex> = Lazy::new(|| {
+    Regex::new(
+        r#"\bimport\(\s*['"]([^'"]+)['"]\s*\)\s*\.then\(\s*(?:async\s+)?(?:function\s*)?\(?\s*([A-Za-z_$][\w$]*)"#,
+    )
+    .unwrap()
+});
+
 pub fn js_bindings(text: &str) -> FileBindings {
     let mut b = FileBindings::default();
     for c in JS_IMPORT.captures_iter(text) {
@@ -205,6 +214,10 @@ pub fn js_bindings(text: &str) -> FileBindings {
                 .insert(lhs.to_string(), Target::Module(c[2].to_string()));
         }
     }
+    for c in JS_DYNAMIC_THEN.captures_iter(text) {
+        b.names
+            .insert(c[2].to_string(), Target::Module(c[1].to_string()));
+    }
     b
 }
 
@@ -565,6 +578,8 @@ pub struct Resolver<'a> {
     /// Python resolution scans every file of the snapshot; the same
     /// importer asks about the same specifier once per caller it checks.
     resolved: RefCell<FxHashMap<(String, String), Resolution>>,
+    /// The repository's own npm packages, by name: (directory, entries).
+    workspace: std::cell::OnceCell<FxHashMap<String, (String, Vec<String>)>>,
 }
 
 impl<'a> Resolver<'a> {
@@ -577,6 +592,7 @@ impl<'a> Resolver<'a> {
             ts_configs,
             cache: RefCell::default(),
             resolved: RefCell::default(),
+            workspace: std::cell::OnceCell::new(),
         }
     }
 
@@ -677,6 +693,63 @@ impl<'a> Resolver<'a> {
             .find(|p| self.files.contains(p))
     }
 
+    /// A specifier naming one of the repository's own packages — an npm
+    /// workspace member — resolves into its source, not to an external
+    /// dependency (#474).
+    fn workspace_package(&self, spec: &str) -> Option<String> {
+        let packages = self.workspace.get_or_init(|| {
+            let mut out = FxHashMap::default();
+            for file in self.files.iter().filter(|f| {
+                (f.as_str() == "package.json" || f.ends_with("/package.json"))
+                    && !f.contains("node_modules/")
+            }) {
+                let Some(doc) = self
+                    .source
+                    .read_to_string(&self.root.join(file))
+                    .and_then(|s| serde_json::from_str::<serde_json::Value>(&s).ok())
+                else {
+                    continue;
+                };
+                let Some(name) = doc["name"].as_str() else {
+                    continue;
+                };
+                let exports = &doc["exports"];
+                let dot = exports.get(".").unwrap_or(exports);
+                let entries: Vec<String> = [
+                    doc["source"].as_str(),
+                    dot.as_str(),
+                    dot["import"].as_str(),
+                    dot["default"].as_str(),
+                    doc["module"].as_str(),
+                    doc["main"].as_str(),
+                ]
+                .into_iter()
+                .flatten()
+                .map(|e| e.trim_start_matches("./").to_string())
+                .collect();
+                out.insert(name.to_string(), (parent_dir(file).to_string(), entries));
+            }
+            out
+        });
+        let (name, (dir, entries)) = packages
+            .iter()
+            .filter(|(n, _)| spec == n.as_str() || spec.starts_with(&format!("{n}/")))
+            .max_by_key(|(n, _)| n.len())?;
+        let at = |rel: &str| normalize(&Path::new(dir).join(rel));
+        let sub = spec[name.len()..].trim_start_matches('/');
+        if sub.is_empty() {
+            entries
+                .iter()
+                .map(|e| at(e))
+                .chain(["src/index", "index"].map(at))
+                .find_map(|p| self.probe_js(&p))
+        } else {
+            [at(sub), at(&format!("src/{sub}"))]
+                .iter()
+                .find_map(|p| self.probe_js(p))
+        }
+    }
+
     fn resolve_js(&self, importer: &str, spec: &str) -> Resolution {
         if spec.starts_with("./") || spec.starts_with("../") || spec == "." || spec == ".." {
             let joined = normalize(&PathBuf::from(parent_dir(importer)).join(spec));
@@ -701,6 +774,9 @@ impl<'a> Resolver<'a> {
                 return Resolution::File(found);
             }
         }
+        if let Some(found) = self.workspace_package(spec) {
+            return Resolution::File(found);
+        }
         let alias_like = spec.starts_with("@/")
             || spec.starts_with("~/")
             || spec.starts_with('#')
@@ -713,6 +789,10 @@ impl<'a> Resolver<'a> {
     }
 }
 
+/// The owner of a method the syntax does not name: an object built inside a
+/// call. A call through any receiver may reach it.
+pub(crate) const UNKNOWN_OWNER: &str = "<object>";
+
 /// How a reference relates to the changed definition.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Evidence {
@@ -813,6 +893,14 @@ fn params_of(content: &str) -> FxHashSet<String> {
             _ => {}
         }
     }
+    // `const x = (f(y) || []).map(…)` opens a parenthesised expression, not
+    // an arrow's parameters: those are followed by `=>` or a return type
+    // (#520).
+    let arrow_form = found.as_str().trim_end().ends_with('(') && found.as_str().contains('=');
+    let rest = head.get(end + 1..).unwrap_or("").trim_start();
+    if arrow_form && !(rest.starts_with("=>") || rest.starts_with(':')) {
+        return FxHashSet::default();
+    }
     head[start..end]
         .split(',')
         .filter_map(|p| {
@@ -1030,7 +1118,7 @@ impl Resolver<'_> {
 
     /// What `receiver.method` says about the receiver being `class`.
     fn receiver_is(&self, site: &Site, chain: &str, def: &Definition, class: &str) -> Evidence {
-        if chain.is_empty() {
+        if chain.is_empty() || class == UNKNOWN_OWNER {
             return Evidence::Candidate("receiver_unresolved");
         }
         if matches!(chain, "self" | "cls" | "this") {
@@ -1069,10 +1157,23 @@ impl Resolver<'_> {
     /// Whether `ctor` (`Bot`, `bots.Bot`) constructs `class`. A name nothing
     /// binds — a factory passed in, a local helper — leaves it unknown.
     fn constructor_is(&self, site: &Site, ctor: &str, def: &Definition, class: &str) -> Evidence {
+        // `model: Any` states no type: the receiver is unknown, not another
+        // class (#425).
+        if matches!(ctor, "Any" | "typing.Any" | "t.Any" | "object") {
+            return Evidence::Candidate("receiver_unresolved");
+        }
         let ctor_head = ctor.rsplit('.').next().unwrap_or(ctor);
         if ctor.contains('.') {
             let module = &ctor[..ctor.len() - ctor_head.len() - 1];
             if ctor_head != class {
+                // `await Model.from_config(…)`: a factory on the class most
+                // often returns one, which the syntax cannot confirm (#425).
+                if module.rsplit('.').next() == Some(class) {
+                    return match self.constructor_is(site, module, def, class) {
+                        Evidence::Rejected => Evidence::Rejected,
+                        _ => Evidence::Candidate("receiver_unresolved"),
+                    };
+                }
                 return Evidence::Rejected;
             }
             let bound = self
@@ -1206,7 +1307,12 @@ pub(crate) fn is_import_line(code: &str) -> bool {
 
 /// Folds one occurrence into the finding: stronger evidence replaces the
 /// lines, equal evidence adds its line, a call outranks a reference.
-fn absorb(best: &mut Option<Finding>, evidence: Evidence, relation: Relation, line: u32) {
+pub(crate) fn absorb(
+    best: &mut Option<Finding>,
+    evidence: Evidence,
+    relation: Relation,
+    line: u32,
+) {
     let Some(f) = best else {
         *best = Some(Finding {
             evidence,

{diffctx-1.19.0 → diffctx-1.19.1}/crates/diffctx-native/src/config/weights.rs

@@ -67,6 +67,7 @@ pub static EDGE_WEIGHTS: Lazy<FxHashMap<&'static str, EdgeWeightConfig>> = Lazy:
         ("php_type", EdgeWeightConfig::new(0.55, 0.40)),
         ("shell_source", EdgeWeightConfig::new(0.60, 0.35)),
         ("shell_script", EdgeWeightConfig::new(0.50, 0.35)),
+        ("shell_call", EdgeWeightConfig::new(0.55, 0.35)),
         ("swift_import", EdgeWeightConfig::new(0.65, 0.40)),
         ("swift_conformance", EdgeWeightConfig::new(0.70, 0.40)),
         ("swift_extension", EdgeWeightConfig::new(0.65, 0.40)),

{diffctx-1.19.0 → diffctx-1.19.1}/crates/diffctx-native/src/edges/semantic/javascript.rs

@@ -32,19 +32,19 @@ fn is_ts_file(path: &Path) -> bool {
 
 static IMPORT_SOURCE_RE: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
-        r#"(?m)(?:import\s+.*?\s+from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))"#,
+        r#"(?m)(?:import\s+.*?\s+from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\)|\bimport\s*\(\s*['"]([^'"]+)['"]\s*\))"#,
     )
     .unwrap()
 });
 static EXPORT_RE: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(r"(?m)^\s*export\s+(?:default\s+)?(?:function|class|const|let|var|interface|type|enum|abstract\s+class)\s+([A-Za-z_$]\w*)").unwrap()
+    Regex::new(r"(?m)^\s*export\s+(?:default\s+)?(?:async\s+)?(?:function(?:\s*\*\s*|\s+)|(?:class|const|let|var|interface|type|enum|abstract\s+class)\s+)([A-Za-z_$]\w*)").unwrap()
 });
 static NAMED_IMPORT_NAMES_RE: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"(?m)import\s*\{([^}]+)\}\s*from").unwrap());
 static CALL_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\b([A-Za-z_$]\w*)\s*\(").unwrap());
 static TYPE_REF_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\b([A-Z]\w*)\b").unwrap());
 static DEF_RE: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(r"(?m)^\s*(?:export\s+)?(?:default\s+)?(?:function|class|const|let|var|interface|type|enum)\s+([A-Za-z_$]\w*)").unwrap()
+    Regex::new(r"(?m)^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function(?:\s*\*\s*|\s+)|(?:class|const|let|var|interface|type|enum)\s+)([A-Za-z_$]\w*)").unwrap()
 });
 
 static JS_KEYWORDS: Lazy<FxHashSet<&str>> = Lazy::new(|| {
@@ -59,10 +59,7 @@ static JS_KEYWORDS: Lazy<FxHashSet<&str>> = Lazy::new(|| {
 fn extract_import_sources(content: &str) -> FxHashSet<String> {
     let mut sources = FxHashSet::default();
     for cap in IMPORT_SOURCE_RE.captures_iter(content) {
-        if let Some(m) = cap.get(1) {
-            sources.insert(m.as_str().to_string());
-        }
-        if let Some(m) = cap.get(2) {
+        for m in [cap.get(1), cap.get(2), cap.get(3)].into_iter().flatten() {
             sources.insert(m.as_str().to_string());
         }
     }
@@ -137,7 +134,18 @@ impl EdgeBuilder for JavaScriptEdgeBuilder {
         let mut frag_defines: FxHashMap<FragmentId, FxHashSet<String>> = FxHashMap::default();
 
         for f in &js_frags {
-            let defines = extract_defines(&f.content);
+            let mut defines = extract_defines(&f.content);
+            // A class or object-literal method is a fragment the grammar
+            // named; no declaration keyword spells it (#444, #473).
+            if f.kind == crate::types::FragmentKind::Function {
+                if let Some(name) = f.symbol_name.as_deref() {
+                    let name = name.split('[').next().unwrap_or(name);
+                    let name = name.rsplit('.').next().unwrap_or(name);
+                    if !name.is_empty() {
+                        defines.insert(name.to_string());
+                    }
+                }
+            }
             for name in &defines {
                 name_to_defs
                     .entry(name.clone())

{diffctx-1.19.0 → diffctx-1.19.1}/crates/diffctx-native/src/edges/semantic/jvm.rs

@@ -72,6 +72,9 @@ static SCALA_CLASS_RE: Lazy<Regex> = Lazy::new(|| {
 static TYPE_REF_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\b([A-Z]\w*)\b").unwrap());
 static ANNOTATION_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"@([A-Z]\w*)").unwrap());
 static MEMBER_USE_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\.\s*([a-zA-Z_]\w{2,})").unwrap());
+/// A call with no receiver: `map(x)`, never `.map(x)` or `obj.map(x)`.
+static UNQUALIFIED_CALL_RE: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"(?:^|[^.\w$])([a-zA-Z_]\w{2,})\s*\(").unwrap());
 /// `UI.DP`: a member too short for the bare channel, spelled with its owner.
 static QUALIFIED_SHORT_USE_RE: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"\b([A-Z]\w*)\s*\.\s*([A-Za-z_]\w?)\b").unwrap());
@@ -867,6 +870,28 @@ impl EdgeBuilder for JVMEdgeBuilder {
                     }
                 }
             }
+            // A Java method calls a sibling of its own file with no
+            // qualifier — `map(x)` in `toDto` — which the dotted member uses
+            // never see (#496). Scala's `apply` and paren-less calls make a
+            // bare name no such call.
+            let java = jf.path().ends_with(".java");
+            let code = crate::parsers::code_only(jf.path(), &jf.content)
+                .filter(|_| java)
+                .unwrap_or_default();
+            for cap in UNQUALIFIED_CALL_RE.captures_iter(&code) {
+                let m = cap[1].to_lowercase();
+                if own.as_deref() == Some(m.as_str()) {
+                    continue;
+                }
+                for d in member_defs.get(&m).into_iter().flatten() {
+                    if d.path.as_ref() == jf.path()
+                        && d != &jf.id
+                        && !(d.start_line <= jf.id.start_line && d.end_line >= jf.id.end_line)
+                    {
+                        add_edge(&mut edges, &jf.id, d, member_weight, reverse_factor);
+                    }
+                }
+            }
             for cap in QUALIFIED_SHORT_USE_RE.captures_iter(&jf.content) {
                 let key = (cap[1].to_string(), cap[2].to_string());
                 for d in owned_short_members.get(&key).into_iter().flatten() {

{diffctx-1.19.0 → diffctx-1.19.1}/crates/diffctx-native/src/edges/semantic/shell.rs

@@ -6,7 +6,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::config::extensions::SHELL_EXTENSIONS;
 use crate::config::weights::EDGE_WEIGHTS;
-use crate::types::Fragment;
+use crate::types::{Fragment, FragmentKind};
 
 use super::super::EdgeDict;
 use super::super::base::{self, EdgeBuilder, FragmentIndex, link_by_name};
@@ -39,6 +39,35 @@ fn extract_refs(content: &str) -> FxHashSet<String> {
     refs
 }
 
+/// Words that run the command after them rather than being it.
+const PREFIX_WORDS: &[&str] = &[
+    "if", "then", "else", "elif", "do", "while", "until", "time", "exec", "command", "builtin",
+    "sudo", "nohup", "env", "!",
+];
+
+/// The command word of every simple command: `run_tool x`, `out=$(run_tool)`,
+/// `a && run_tool`, `if run_tool; then`.
+fn command_words(content: &str) -> FxHashSet<&str> {
+    let mut words = FxHashSet::default();
+    for line in content.lines() {
+        if line.trim_start().starts_with('#') {
+            continue;
+        }
+        for part in line.split([';', '|', '&', '(', ')', '`', '{', '}']) {
+            let word = part
+                .split_whitespace()
+                .find(|t| !t.contains('=') && !PREFIX_WORDS.contains(t));
+            if let Some(w) = word.filter(|w| {
+                w.chars()
+                    .all(|c| c.is_alphanumeric() || matches!(c, '_' | '-' | ':' | '.'))
+            }) {
+                words.insert(w);
+            }
+        }
+    }
+    words
+}
+
 pub struct ShellEdgeBuilder;
 
 impl EdgeBuilder for ShellEdgeBuilder {
@@ -103,6 +132,51 @@ impl EdgeBuilder for ShellEdgeBuilder {
             }
         }
 
+        // A function is called by name as a command word, from its own file
+        // or from one that sources it. Without this edge a call from a
+        // script's body was a lexical match only, and impact read the
+        // function as one nothing calls (#497).
+        let call = EDGE_WEIGHTS["shell_call"];
+        let file_name = |p: &str| p.rsplit('/').next().unwrap_or(p).to_string();
+        let mut sourced: FxHashMap<&str, FxHashSet<String>> = FxHashMap::default();
+        for f in &sh_frags {
+            for cap in SOURCE_RE.captures_iter(&f.content) {
+                sourced
+                    .entry(f.path())
+                    .or_default()
+                    .insert(file_name(&cap[1]));
+            }
+        }
+        let functions: Vec<&Fragment> = sh_frags
+            .iter()
+            .copied()
+            .filter(|f| f.kind == FragmentKind::Function && f.symbol_name.is_some())
+            .collect();
+        for f in &sh_frags {
+            let words = command_words(&f.content);
+            for def in &functions {
+                let reachable = def.path() == f.path()
+                    || sourced
+                        .get(f.path())
+                        .is_some_and(|s| s.contains(&file_name(def.path())));
+                if def.id != f.id
+                    && reachable
+                    && def
+                        .symbol_name
+                        .as_deref()
+                        .is_some_and(|n| words.contains(n))
+                {
+                    base::add_edge(
+                        &mut edges,
+                        &f.id,
+                        &def.id,
+                        call.forward,
+                        call.reverse_factor,
+                    );
+                }
+            }
+        }
+
         edges
     }
 

{diffctx-1.19.0 → diffctx-1.19.1}/crates/diffctx-native/src/fragmentation.rs

@@ -55,7 +55,6 @@ static GENERATED_PATH_SEGMENTS: Lazy<FxHashSet<&'static str>> = Lazy::new(|| {
 
 const GENERATED_CONTENT_MARKERS: &[&str] = &[
     "@generated",
-    "do not edit",
     "code generated",
     "auto-generated",
     "this file is generated",
@@ -108,6 +107,12 @@ fn has_generated_content_marker(content: &str) -> bool {
         .collect::<Vec<_>>()
         .join("\n")
         .to_lowercase();
+    // "Do not edit" is a generator's warning only beside the word that says
+    // a generator wrote it; a hand-written "do not edit without approval"
+    // marks a file people do edit (#411).
+    if header.contains("do not edit") && header.contains("generat") {
+        return true;
+    }
     for marker in GENERATED_CONTENT_MARKERS {
         if !header.contains(marker) {
             continue;

{diffctx-1.19.0 → diffctx-1.19.1}/crates/diffctx-native/src/git.rs

@@ -1522,11 +1522,9 @@ pub fn grep_code_words(
         .iter()
         .map(|ext| format!(":(glob,icase)**/*{ext}"))
         .collect();
+    let patterns = Patterns::new(words);
     let mut args: Vec<&str> = vec!["grep", "-n", "-z", "-I", "-F", "-w", "-m", &per_file];
-    for w in words {
-        args.push("-e");
-        args.push(w);
-    }
+    args.extend(patterns.args.iter().map(String::as_str));
     args.extend(rev);
     args.push("--");
     args.extend(globs.iter().map(String::as_str));
@@ -1543,15 +1541,53 @@ pub fn grep_lines(
     if needles.is_empty() {
         return Ok(Grepped::default());
     }
+    let patterns = Patterns::new(needles);
     let mut args: Vec<&str> = vec!["grep", "-n", "-z", "-I", "-F"];
-    for n in needles {
-        args.push("-e");
-        args.push(n);
-    }
+    args.extend(patterns.args.iter().map(String::as_str));
     args.extend(rev);
     grep_rows(repo_root, &args, rev)
 }
 
+/// `-f FILE` naming the patterns one per line, or `-e` per pattern when the
+/// file cannot be written: tens of thousands of `-e` arguments overflow
+/// ARG_MAX and the whole search fails (#440). The file goes with the value.
+struct Patterns {
+    file: Option<PathBuf>,
+    args: Vec<String>,
+}
+
+impl Patterns {
+    fn new(words: &[String]) -> Self {
+        // An empty line would match every line.
+        let listed: Vec<&str> = words
+            .iter()
+            .map(String::as_str)
+            .filter(|w| !w.is_empty())
+            .collect();
+        match write_private_temp_file(&listed.join("\n")) {
+            Some(file) => Self {
+                args: vec!["-f".to_string(), file.to_string_lossy().into_owned()],
+                file: Some(file),
+            },
+            None => Self {
+                file: None,
+                args: listed
+                    .iter()
+                    .flat_map(|w| ["-e".to_string(), (*w).to_string()])
+                    .collect(),
+            },
+        }
+    }
+}
+
+impl Drop for Patterns {
+    fn drop(&mut self) {
+        if let Some(file) = &self.file {
+            let _ = std::fs::remove_file(file);
+        }
+    }
+}
+
 pub fn get_untracked_files(repo_root: &Path, pathspec: &[String]) -> Result<Vec<PathBuf>> {
     let mut args: Vec<&str> = vec!["ls-files", "--others", "--exclude-standard", "-z"];
     if !pathspec.is_empty() {