diffctx 1.18.4__tar.gz → 1.19.0__tar.gz

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

@@ -7,6 +7,267 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.19.0] - 2026-10-14
+
+### Added
+
+- Kotlin (`.kt`, `.kts`) parses with tree-sitter, through
+  `brokk-tree-sitter-kotlin` 0.4.6 — the fwcd grammar as its maintained fork
+  publishes it, since fwcd's own crate still pins tree-sitter < 0.23. On
+  1,036 real files it lost no declaration and broke on none;
+  `tree-sitter-kotlin-sg` 0.4.1 silently dropped seven classes (a bodyless
+  annotated class swallowed the next one) and `tree-sitter-kotlin-ng` broke
+  whole classes on a `get(...)` call. Classes, interfaces, objects,
+  companions (`Companion` when unnamed), functions, extension functions,
+  secondary constructors (named after their class), properties (a property
+  spans its getter and setter; a local `val` is not a member) and type
+  aliases become fragments (#303). This reverses the 1.7.0 removal, which
+  dropped `.kt` read through the Java grammar, not a Kotlin one.
+- Kotlin has a binding model, read off shared syntax facts (one parse per
+  blob, shared by the fragmenter, `--symbol` and impact): a use binds through
+  its import or alias, the declared package (not the directory), the
+  receiver's declared type — a local, a parameter, a property of the class
+  or of a source-visible base class, a constructor or a function with a
+  written return type, called plainly or on a typed name
+  (`val x = repo.find(id)`) — an object or companion qualifier, or the
+  implicit `this`, which in an `inner class` reaches the outer instance too.
+  What the syntax cannot settle stays a candidate with its reason
+  (`receiver_unresolved`, `overloaded`, `wildcard_import`, `dispatch`,
+  `project_dependency_unknown`); `internal` stops at the project, which its
+  test source set shares. Callable references (`Obj::f`) are references,
+  implementations of a changed abstract member are their own relation, a
+  removed declaration is found by comparing the file's declarations at the
+  base and the head, and a public contract changes when the header does —
+  parameter defaults and all. In the context graph a Kotlin member use links
+  only to the definition it resolves to: a candidate suggests, it does not
+  link.
+
+### Security
+
+- Impact and `--symbol` no longer name a withheld file that refers to the
+  change. 1.18.4's fix covered the changed side only: a file under
+  `.diffctx/ignore` or with a secret name that called a removed definition or
+  named a deleted path still appeared as a caller or a stale reference. The
+  withhold policy now applies inside the `git grep` readers, so every surface
+  gets only admissible files, and the files a read withheld count toward
+  `withheld_files`. The header says "N file(s) withheld by ignore rules"
+  rather than "N more", since they need not be changed files.
+
+### Fixed
+
+- **`A..B` is what `B` changed since it forked from `A`**, in every mode and
+  at every entry point (CLI, MCP, the hook, the Action): the range resolves
+  once to the merge base and `B`'s commit. Read as two trees, a base that
+  moved on after the fork put its own later commits into the change as
+  reverts — a PR's target branch in the Action (#485), a remote-tracking
+  ref a `pull` on the same line had just moved in the hook (#462, which now
+  also measures a push from where the push itself found the ref). The
+  Action deepens a shallow checkout until the fork point is known, and says
+  so when it is not. Histories with no common commit keep git's two-tree
+  reading.
+- A range is answered from its snapshot alone. The Helm chart root was
+  probed on the disk, so a working tree without the range's `Chart.yaml`
+  dropped the chart's templates from pack and locate (#408). A snapshot
+  read that failed — out of time, cancelled, a broken stream — read as an
+  absent file and now names its limit; a snapshot listing that failed no
+  longer hands discovery or the token cache the working tree's files in its
+  place (#443).
+- The changed-file count of uncommitted work is what git would commit.
+  Untracked files are analysed as before but named apart (`untracked_files`,
+  "2 changed file(s), 1 untracked"), and an untracked binary — a local
+  database, a build artefact — is no source change at all; two `.db` files
+  and a notes file read as "5 changed file(s)" for a 2-file edit (#418,
+  #423). A search for a name defined only in an untracked file is answered
+  with its callers, as the inspection that follows already was (#448).
+- `--full A..B` listed a file the range deleted, or renamed away, as
+  changed and showed its old body read from `A`. One rule now names what a
+  range's head no longer holds, for every mode; staged pack, `--full` and
+  locate are pinned to read the index alone, renames and mode changes
+  included (#409).
+- A one-second impact run ends near its second: the loops over input-sized
+  lists (stale-reference lines, unanalysed and namer files, test edges)
+  iterate through the deadline instead of polling it by hand, and the
+  stale-reference loop, which had no poll, ran such a run to 4.5 s (now
+  1.04 s, #510). A deadline that loop hit is named in `limits`; it was read
+  before the loop ran, so a run that had dropped its stale references
+  looked complete. `DIFFCTX_TEST_DEADLINE_AFTER_POLLS=n` stops a run at its
+  `n`th poll, so tests stop it at every point without racing the clock,
+  and a corpus case its deadline stopped says so instead of failing on a
+  score (#390).
+- A call inside an f-string replacement field (`f"{fence(text)}"`) or a
+  template-literal substitution (`` `${formatBytes(n)}` ``) is a caller. The
+  hand lexer that impact and the binding resolver read code through
+  blanked every quoted byte, interpolations included, so both read
+  "0 callers" (#460, #475). Comments and string literals now come off the
+  file's grammar, interpolations kept, in every language with one; the
+  lexer and its special cases (`//` as floor division, a Rust lifetime,
+  `*` block-comment lines) are gone (#506).
+- A removed definition is one the file declared at the base and does not
+  declare at the head, both read off the grammar. Read off removed lines by
+  regex, a Rust tail expression `Err("zero")` became a removed member named
+  `Err` with every `Err(` in the crate as its callers, a bare `int(text)` in
+  a Python method a removed `int`, and a private function next to an
+  `impl` a removed API (#515, #458). A member is as public as the class or
+  interface it sits in, by nesting, not by the nearest class above it.
+- A caller of a removed definition is code that can still reach it:
+  through an import the binding model resolves to the file it left (a
+  removed member through its imported class), else from the same runtime.
+  By name alone, `subprocess.run`, another file's own `run`, a shell `die`
+  and a TypeScript `test.describe` were callers of a deleted Python script's
+  functions, and the import line was a second caller (#470, #471, #458,
+  #450). Files the range deleted resolve as files an import still names.
+- A dependency bump is a change: impact names the lock files a range
+  changes (`lockfile_changes`) and never answers "No changes to analyse" for
+  them (#495).
+- The hook's search pre-filter in the plugin script read the session's
+  cwd, not the Grep's own `path`, and ignored untracked files, so a search
+  over a pending change elsewhere never reached the binary. `bash -lc
+  "git commit …"` and `$(git -C r commit)` are named as unread rather than
+  logged as no trigger; reminders and gate denials are logged as such. A
+  cache directory the hook cannot write falls back to the temporary
+  directory instead of silently rerunning every preview (#407).
+- Before a commit or push the hook says what it did when it has no impact
+  to show: one line when the change reaches nothing outside the diff, and
+  one when it could not read the command (a git inside a subshell, a `cd`
+  it cannot resolve), with the command to run instead. Silence then means
+  the hook did not run, not a clean review; the hook log keeps tens of
+  thousands of runs so an audit reads a whole session (#464).
+- The MCP tool timed out at 300 s on a monorepo range the CLI answered in
+  four seconds (#457), for two reasons. It widened a subdirectory
+  `repo_path` to the whole repository; it now analyses the directory asked
+  about, as the CLI does with the same path. And impact grepped every
+  removed name as a fixed string in every file, so a deleted `call` matched
+  each `callback` in the repository's data and the run never stopped
+  (#413): the grep now reads whole words in code files only, at most 20
+  lines a file, and a name on more than 500 lines is answered "too common to
+  trace by name" instead of listed.
+- Impact is fitted to its cap on the text the reader receives: markdown was
+  shed against the size of its JSON, so a 148-token answer cited a
+  2000-token cap and lost its contract block; an omitted count printed
+  under the previous list's heading (#451). `--budget` (CLI) and
+  `budget_tokens` (MCP) set the cap, which stayed 2000 whatever was asked,
+  and a shed answer says which flag lists the rest (#466).
+- The MCP tool's refusal of `symbol` together with `diff_ref` or
+  `fragment_ids` names the call that answers: drop them and ask in
+  `mode="impact"`, which looks the name up in the working tree (#499).
+- Impact no longer reads "not examined" as "nothing there". A failed `git
+  grep` or file listing marks the run partial (`read_failed`) instead of
+  dropping the removed definition's callers and the stale references with
+  exit 0; a failed snapshot listing no longer falls back to the working
+  tree. A changed code file over the size cap or unreadable is named in
+  `unanalysed_files` (it answered `"empty": true` while pack said
+  `file_too_large`). Limits follow pack's rule, so the contribution and
+  total-byte caps, which drop callers, are named; the per-node edge cap
+  every repository trips still is not. A caller whose edge that cap cut
+  faces the same tests an edge would have and stays a caller (`--symbol`
+  answered "0 callers" for a function its route handler calls). A
+  definition changed only in comments, formatting or position is listed
+  in `layout_only` and the answer says its callers were not traced, where
+  it said "No resolved static callers"; the hook's search answer says the
+  same instead of claiming none. Under a limit, "nothing calls them" reads
+  "no caller found in this partial run". Unparsed files that name a
+  camelCase definition are disclosed: identifiers are stored lowercased,
+  and the lookup compared them as written.
+- Impact no longer calls a definition whose only callers are inside the diff
+  one that "nothing calls": a helper extracted from a function the same
+  commit changes read as dead code, on 62–75% of that list across three
+  ranges of this repository. Such definitions are listed under "Changed,
+  called only from inside the diff, no static test link" and in the new
+  `untested_called_in_diff` field; an in-diff source counts when it passes
+  the tests any caller passes. 1.18.3 never printed the clause, so 1.18.4
+  added the false statement (#441).
+- A control statement removed from a method body is no removed member:
+  `match (a, b) {` in a Rust `impl` read as a removed API `match`, and
+  every file spelling the keyword became its caller. `when`, `try`,
+  `synchronized`, `using`, `lock`, `fixed`, `foreach` and `elseif` are
+  filtered with it (#492).
+- Impact looks a fragment id up as the fragment, not as the signature
+  variant that shares its id when the signature spans the whole fragment: a
+  Kotlin class whose header ends in `) {` answered `--symbol` with "0
+  definition(s)".
+- The JVM builder links an owner-qualified short member (`UI.DP`) to its
+  declaration. Names under three characters never linked by name, so a
+  constant read through its object was missed.
+- A JVM framework annotation registers what it annotates and nothing else:
+  a class-level `@Component` or `@Service` no longer marks every method a
+  registered entry point (which hid its missing test link); method-level
+  entry points (`@GetMapping`, `@Scheduled`, `@Bean`, …) count only when the
+  file imports them from a framework package.
+- Impact names a caller by its whole definition, not by the signature
+  variant the graph linked: a use in the body — a constructor call after a
+  long parameter list — was dropped from the caller's sites.
+- A name shared across runtimes no runtime crosses is neither a caller nor
+  a test link: a Kotlin test no longer reads as guarding a Swift function of
+  the same name, and a Kotlin or Swift spelling of a Python or TypeScript
+  name is not its caller. JVM languages still call each other, JavaScript
+  its HTML and components, Swift and Objective-C their C (#487, #458).
+- A changed symbol whose name is spelled in a file in view that did not
+  parse cleanly lists that file (`missed_in`, "callers may be missing")
+  instead of reading as one nothing calls (#454).
+- JVM tests pair with their subject the way JVM projects name them:
+  `FooTest`, `FooTests`, `FooSpec` and `FooIT` beside `Foo` are discovered
+  and linked in both directions, and `src/<set>/<java|kotlin|scala|groovy>/`
+  is a source root, so a test importing `com.acme.Foo` reaches
+  `src/main/kotlin/com/acme/Foo.kt`. A related test file is not a guard: a
+  method its tests never call keeps "no static test link".
+- `--symbol Owner.name` reads Kotlin's owners and receivers from the syntax:
+  `String.pad` names the extension, `Worker.Companion.create` the companion
+  member; and the declaration search that keeps a capped query's definition
+  file knows `fun` and `typealias`.
+- A Kotlin type the text declares at the start of a line but the parse did
+  not read — a grammar's silent misreading, with no error node — marks the
+  file analysed only in part (0 of yay-tsa's 1,036 files with the shipped
+  grammar; local classes count as read).
+- The parse outcome is recorded when the fragmenter parses a file, not
+  inferred from the fragments that came out: a file that parsed with errors
+  is reported as analysed only in part even when a definition survived, and
+  a timed-out parse is named as such.
+
+- Impact names the changed code files it could not read for definitions —
+  no grammar for the language in this build, or a parse that broke — in its
+  header and in `unanalysed_files`, and never calls such a change empty: a
+  Kotlin-only commit read "0 callers outside the diff" and the commit hook
+  stayed silent (#454). A script that parses cleanly and defines nothing is
+  not listed.
+- `--symbol` no longer answers only "no definition found" when the files
+  naming the symbol were read as text: it names them and the reason, so an
+  unparsed definition is not mistaken for a missing one (#454).
+- Locate's `unparsed_files` uses the same test: code with no grammar in this
+  build (Kotlin, F#, Fortran) or a broken parse is listed and lowers
+  confidence; a script that parses cleanly and defines nothing (a
+  `build.gradle.kts`, a Python script of top-level statements) no longer is.
+  Data files (`.sql`, `.toml`, `.txt`) stay unlisted (#330).
+
+### Changed
+
+- **Plugin hook: a commit, merge, cherry-pick, revert or push is reviewed
+  from what git recorded, once the line ran** — read off the reflog (`HEAD`'s
+  last entry, a remote-tracking ref's "update by push"), never predicted
+  from the command text. The prediction took fifteen parser commits in
+  nine days and still reviewed another session's staged file for
+  `git commit --pathspec-from-file` instead of the paths the commit took
+  (#508). A loop, `xargs`, `git apply --cached`, `git --git-dir … commit` or
+  an escaped quote now stage what they stage, and the review says what the
+  commit took (#405, #436). A commit of a change already shown gets a
+  one-line pointer instead of silence (#501); a push of several refs
+  reviews the first and counts the rest; a `--squash` merge is reviewed by
+  the commit that records it. `L=/abs; cd $L && git commit` follows the
+  variable the line sets (#422). The opt-in strict gate still reviews
+  before git runs, and only what needs no prediction: the index a plain
+  `git commit` records; a commit line that stages for itself is denied with
+  the instruction to stage as its own command. Without the gate the impact
+  now arrives with the commit's result, which is when Claude Code delivered
+  the old preview too (#429).
+- Claude plugin: the MCP server and the hooks launch `uvx diffctx[mcp]==X`
+  with no other option, and `plugin/uv.lock` pins the release's whole
+  dependency tree with PyPI hashes, the shape the plugin directory reads as a
+  locked launch ("Launcher lock invalid" before). `constraints.txt` is gone:
+  uv resolves diffctx's dependencies within their declared ranges, as every
+  other uvx install already did.
+- CI and the pre-commit hook run the `impact`, `hook`, `bindings`, `staged`,
+  `git_faults`, `in_memory` and `context_schema` test targets, which no gate
+  ran before.
+
 ## [1.18.4] - 2026-10-07
 
 ### Security
@@ -2038,7 +2299,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.18.4...HEAD
+[Unreleased]: https://github.com/nikolay-e/diffctx/compare/v1.19.0...HEAD
+[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
 [1.18.2]: https://github.com/nikolay-e/diffctx/compare/v1.18.1...v1.18.2

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

@@ -94,6 +94,16 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
+[[package]]
+name = "brokk-tree-sitter-kotlin"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11536d4605247354ad8992b7ae605e85508c07d64ed0710ff8494558660e40d0"
+dependencies = [
+ "cc",
+ "tree-sitter-language",
+]
+
 [[package]]
 name = "bstr"
 version = "1.13.1"
@@ -107,9 +117,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.60"
+version = "1.2.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -194,10 +204,11 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "diffctx"
-version = "1.18.4"
+version = "1.19.0"
 dependencies = [
  "aho-corasick",
  "anyhow",
+ "brokk-tree-sitter-kotlin",
  "clap",
  "dunce",
  "glob",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffctx
-Version: 1.18.4
+Version: 1.19.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -77,7 +77,7 @@ zero.
 ## Install
 
 ```bash
-# Claude Code: the MCP server, /diffctx:impact, and hooks that run it before commit and push
+# Claude Code: the MCP server, /diffctx:impact, and hooks that run it on each commit and push
 claude plugin marketplace add nikolay-e/diffctx
 claude plugin install diffctx@diffctx
 

{diffctx-1.18.4 → diffctx-1.19.0}/README.md

@@ -18,7 +18,7 @@ zero.
 ## Install
 
 ```bash
-# Claude Code: the MCP server, /diffctx:impact, and hooks that run it before commit and push
+# Claude Code: the MCP server, /diffctx:impact, and hooks that run it on each commit and push
 claude plugin marketplace add nikolay-e/diffctx
 claude plugin install diffctx@diffctx
 

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

@@ -1,6 +1,6 @@
 [package]
 name = "diffctx"
-version = "1.18.4"
+version = "1.19.0"
 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"
@@ -66,6 +66,7 @@ lang-extra = [
     "tree-sitter-svelte-ng",
     "tree-sitter-scala",
     "tree-sitter-swift",
+    "brokk-tree-sitter-kotlin",
 ]
 
 [dependencies]
@@ -86,6 +87,14 @@ tree-sitter-ruby = { version = "0.23", optional = true }
 tree-sitter-php = { version = "0.24", optional = true }
 tree-sitter-scala = { version = "0.26", optional = true }
 tree-sitter-swift = { version = "0.7", optional = true }
+# The fwcd grammar (fwcd's own crate stops at 0.3.8, pinned to tree-sitter
+# < 0.23, fwcd#242), as BrokkAi publishes its maintained fork with symbol-
+# prefixed C exports. Exact pin: a fork's next release is reviewed, not taken.
+# On yay-tsa's 1,036 files it lost no type declaration and broke on none;
+# tree-sitter-kotlin-sg 0.4.1 silently dropped 7 classes (a bodyless
+# annotated class swallowed the next one) and broke 5 Compose files, and
+# tree-sitter-kotlin-ng dropped 8 and broke whole classes on `get(...)`.
+brokk-tree-sitter-kotlin = { version = "=0.4.6", optional = true }
 tree-sitter-html = { version = "0.23", optional = true }
 tree-sitter-bash = { version = "0.25", optional = true }
 tree-sitter-css = { version = "0.25", optional = true }

{diffctx-1.18.4 → diffctx-1.19.0}/crates/diffctx-native/README.md

@@ -18,7 +18,7 @@ zero.
 ## Install
 
 ```bash
-# Claude Code: the MCP server, /diffctx:impact, and hooks that run it before commit and push
+# Claude Code: the MCP server, /diffctx:impact, and hooks that run it on each commit and push
 claude plugin marketplace add nikolay-e/diffctx
 claude plugin install diffctx@diffctx
 

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

@@ -747,6 +747,8 @@ impl Evidence {
 pub enum Relation {
     Call,
     Reference,
+    /// A class that implements the changed abstract member.
+    Implementation,
 }
 
 /// The changed definition: `name` in `path`, a method of `class` when it
@@ -1056,9 +1058,8 @@ impl Resolver<'_> {
                 return direct;
             }
         }
-        let python = lang_of(site.path) == Some(Lang::Python);
-        if let Some(ctor) =
-            constructed_as(site.content, head, python).or_else(|| annotated_as(site.content, head))
+        if let Some(ctor) = constructed_as(site.path, site.content, head)
+            .or_else(|| annotated_as(site.content, head))
         {
             return self.constructor_is(site, &ctor, def, class);
         }
@@ -1097,12 +1098,10 @@ impl Resolver<'_> {
     pub fn classify(&self, site: &Site, def: &Definition) -> Option<Finding> {
         let words = self.names_for(site, def);
         let params = params_of(site.content);
-        let python = lang_of(site.path) == Some(Lang::Python);
-        let mut triple = None;
         let mut best: Option<Finding> = None;
-        for (i, line) in site.content.lines().enumerate() {
-            let code = crate::impact::mask_code(line, python, &mut triple);
-            if is_import_line(&code) {
+        let masked = crate::impact::code_text(site.path, site.content);
+        for (i, code) in masked.lines().enumerate() {
+            if is_import_line(code) {
                 continue;
             }
             let line_no = site.start_line + i as u32;
@@ -1198,7 +1197,7 @@ impl Resolver<'_> {
     }
 }
 
-fn is_import_line(code: &str) -> bool {
+pub(crate) fn is_import_line(code: &str) -> bool {
     let head = code.trim_start();
     head.starts_with("import ")
         || head.starts_with("from ")
@@ -1260,21 +1259,21 @@ fn bases_of(header: &str) -> Vec<String> {
 /// constructor `x` holds. A binding is read within one line: across a
 /// newline, `as srv:` and the next line's `result = srv.call_tool(...)`
 /// read as an annotated assignment from `srv.call_tool` (#399).
-fn constructed_as(content: &str, var: &str, python: bool) -> Option<String> {
+fn constructed_as(path: &str, content: &str, var: &str) -> Option<String> {
     let re = Regex::new(&format!(
         r"(?:^|[^\w$.])({})\s*(?::\s*[\w$.\[\]<>]+\s*)?=\s*(?:new\s+|await\s+)?([\w$.]+)\s*\(",
         regex::escape(var)
     ))
     .ok()?;
-    let mut triple = None;
-    content.lines().find_map(|line| {
-        let code = crate::impact::mask_code(line, python, &mut triple);
-        entered_as(&code, var).or_else(|| {
-            re.captures_iter(&code)
-                .find(|c| c.get(1).is_some_and(|v| !after_as(&code, v.start())))
-                .map(|c| c[2].to_string())
+    crate::impact::code_text(path, content)
+        .lines()
+        .find_map(|code| {
+            entered_as(code, var).or_else(|| {
+                re.captures_iter(code)
+                    .find(|c| c.get(1).is_some_and(|v| !after_as(code, v.start())))
+                    .map(|c| c[2].to_string())
+            })
         })
-    })
 }
 
 /// Whether the name at `at` is the target of an `as` (`with … as x`,

{diffctx-1.18.4 → diffctx-1.19.0}/crates/diffctx-native/src/candidate_files.rs

@@ -109,13 +109,21 @@ pub fn collect_candidate_files(
     ctx: &crate::resource::RunContext,
 ) -> Vec<PathBuf> {
     let source = crate::source::current();
-    if let Some(blobs) = source.list_blobs(scope) {
-        let admitted = blobs
-            .into_iter()
-            .filter(|b| is_snapshot_candidate(b, root_dir, included_set, &source, ctx))
-            .map(|b| b.path)
-            .collect();
-        return filter_ignored_and_secret(root_dir, admitted);
+    match source.list_blobs(scope) {
+        Some(Ok(blobs)) => {
+            let admitted = blobs
+                .into_iter()
+                .filter(|b| is_snapshot_candidate(b, root_dir, included_set, &source, ctx))
+                .map(|b| b.path)
+                .collect();
+            return filter_ignored_and_secret(root_dir, admitted);
+        }
+        Some(Err(e)) => {
+            tracing::warn!("discovery: the snapshot's listing failed ({e})");
+            ctx.note(crate::resource::reason_for(&e));
+            return Vec::new();
+        }
+        None => {}
     }
     match tracked_candidates(root_dir, included_set, scope, ctx) {
         Some(files) => filter_ignored_and_secret(root_dir, files),

{diffctx-1.18.4 → diffctx-1.19.0}/crates/diffctx-native/src/discovery.rs

@@ -316,6 +316,13 @@ impl DiscoveryStrategy for TestFileDiscovery {
             for suffix in TEST_SUFFIXES {
                 test_stems.insert(format!("{stem}{suffix}"));
             }
+            let ext = crate::edges::base::file_ext(f);
+            if crate::edges::structural::testing::JVM_TEST_SUFFIX_EXTENSIONS.contains(&ext.as_str())
+            {
+                for suffix in crate::edges::structural::testing::JVM_TEST_SUFFIXES {
+                    test_stems.insert(format!("{stem}{suffix}"));
+                }
+            }
         }
 
         let mut discovered: Vec<PathBuf> = Vec::new();

{diffctx-1.18.4 → diffctx-1.19.0}/crates/diffctx-native/src/edges/base.rs

@@ -47,10 +47,19 @@ pub trait EdgeBuilder: Send + Sync {
 static INDEX_FILE_STEMS: Lazy<FxHashSet<&str>> =
     Lazy::new(|| ["__init__", "index", "mod"].iter().copied().collect());
 
+/// JVM source roots: `src/<source set>/<language>/` precedes the package
+/// path in Gradle and Maven layouts, so `src/test/kotlin/com/acme/FooTest`
+/// is the module `com.acme.FooTest`, the name its imports spell.
+const JVM_SOURCE_LANGUAGES: &[&str] = &["java", "kotlin", "scala", "groovy"];
+
 fn strip_source_prefix(parts: &[&str]) -> Vec<String> {
     for (i, part) in parts.iter().enumerate() {
         if *part == "src" || *part == "lib" || *part == "packages" {
-            return parts[i + 1..].iter().map(|s| s.to_string()).collect();
+            let mut rest = &parts[i + 1..];
+            if *part == "src" && rest.len() > 2 && JVM_SOURCE_LANGUAGES.contains(&rest[1]) {
+                rest = &rest[2..];
+            }
+            return rest.iter().map(|s| s.to_string()).collect();
         }
     }
     parts.iter().map(|s| s.to_string()).collect()

{diffctx-1.18.4 → diffctx-1.19.0}/crates/diffctx-native/src/edges/config_edges/helm.rs

@@ -79,10 +79,16 @@ fn extract_yaml_keys(content: &str, max_depth: usize) -> FxHashSet<String> {
     keys
 }
 
+/// The chart directory above `path`, in the analysed source: a snapshot's
+/// chart is its own, whatever the disk holds (#408).
 fn get_chart_root(path: &Path) -> Option<PathBuf> {
+    let source = crate::source::current();
     let mut current = path.parent()?.to_path_buf();
     for _ in 0..5 {
-        if current.join("Chart.yaml").exists() || current.join("chart.yaml").exists() {
+        if ["Chart.yaml", "chart.yaml"]
+            .iter()
+            .any(|name| source.read_bytes(&current.join(name)).is_some())
+        {
             return Some(current);
         }
         let parent = current.parent()?;

{diffctx-1.18.4 → diffctx-1.19.0}/crates/diffctx-native/src/edges/mod.rs

@@ -418,10 +418,13 @@ fn collect_capped_edges_from(
     cap_out_edges_per_source(&mut edges, max_per_node);
     ctx.record_usage(|u| u.final_edges = edges.len() as u64);
 
-    let nodes_capped = out_degree
+    let capped_sources: FxHashSet<FragmentId> = out_degree
         .iter()
-        .filter(|&&d| d as usize > max_per_node)
-        .count();
+        .enumerate()
+        .filter(|&(_, &d)| d as usize > max_per_node)
+        .map(|(i, _)| idx_to_node[i].clone())
+        .collect();
+    let nodes_capped = capped_sources.len();
     let cap_stats = EdgeCapStats {
         edges_before_cap: deduped_edge_count,
         edges_after_cap: edges.len(),
@@ -429,6 +432,7 @@ fn collect_capped_edges_from(
         nodes_capped,
         max_out_edges_per_node: max_per_node,
         emissions_by_category,
+        capped_sources,
     };
 
     CappedEdges {