diffctx 1.18.3__tar.gz → 1.19.0__tar.gz

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

@@ -7,6 +7,402 @@ 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
+
+- Impact no longer names a file the run withholds (`.diffctx/ignore`, a
+  secret name): a definition removed from it, its deletion or its rename
+  reached the answer while pack reported only a withheld count.
+
+### Changed
+
+- The MCP server runs on the MCP Python SDK 2.3 (`mcp>=2.3,<3`): it answers
+  the `server/discover` probe Claude Code opens with, instead of rejecting it
+  with 31 validation errors on every connect, and still accepts every
+  `initialize` revision back to 2024-11-05 (#366).
+- `ChangeClass` gains `layout`: a file whose diff changes only whitespace,
+  comments, quote style, trailing commas, semicolons or import order. Pack
+  ranks it with `mechanical` (#370).
+- `diffctx graph --level file|directory` now applies to `-f json`, `-f
+  graphml` and the `--summary` counts; without `--level` they stay per
+  fragment (#352).
+
+### Fixed
+
+- Plugin hook: the commit is previewed as the index it will start from — the
+  line's own `git add`/`git rm` replayed on a copy of the index, `-a`, a
+  pathspec with `--only` semantics, `-i`, `--amend`, a first commit, a linked
+  worktree — instead of the whole working tree; a here-document message is no
+  pathspec; a multi-commit cherry-pick is reviewed whole; `cd ~/repo` is
+  followed; a diff written to a file is no inspection; an empty answer stays
+  empty after the commit lands (#384, #373, #380, #377). The session hint
+  names `--symbol` again (#379).
+- Impact: the header counts every caller its lines call untested, says
+  "callers unresolved" instead of "0 caller(s)" when no binding model could
+  resolve them, says when the run stopped early, and counts changed
+  definitions no test reaches (#386, #387, #335). A caller registered by a
+  decorator (`@register_node`, `@app.route`) is no longer called untested
+  (#388). Adding fields or parameters with defaults collapses the call sites
+  into one signature-compatible line (#388); formatting- or comment-only edits
+  are no contract and list no callers (#370). An unchanged caller in a changed
+  file is listed (#362). `pub` inside a `pub(crate)` module is no public API
+  (#359); a script named for a schema is no schema contract (#374). A deleted
+  path is matched by its path, a relative path, its module name or a
+  basename no other file has, never by a bare word (#369, #383). A removed
+  member and the remaining `?.()` calls to it are reported (#367).
+- Impact on a large changed module took 74 s on one core; per-file indexes and
+  memoized test links bring it to 4 s with byte-identical output (#385). The
+  Python CLI's watchdog waits the binary's 30 s grace past `--timeout`, so a
+  run that stops at its deadline answers partially instead of exiting 124
+  with nothing (#382).
+- MCP: `diff_ref="HEAD"` is documented as the uncommitted work, and a clean
+  tree answers with the hint that `HEAD~1..HEAD` is the last commit (#368).
+- Selection: changed code is placed by evidence tier (production, tests,
+  config and docs, mechanical or layout edits, generated files) and by how
+  densely each piece carries the change, not cheapest-first; a core the
+  first pass could only place as its signature stub gets its body when the
+  difference fits (#296, #327). A Django migration ("Generated by Django")
+  is no longer a generated file ranked last (#311).
+- Graph: a range's own commits no longer vouch for its files in the
+  co-change channel, which now links two files once, representative to
+  representative (#340). The tags fallback no longer links files of a
+  language its own builder parsed (a stdlib module name, a keyword); a key
+  most config files carry (`workflow_dispatch` in every CI workflow) links
+  no source file to all of them (#286, #297); a setting spelled whole
+  (`database_url` in two of four environment files) still links its reader.
+  A bare `--diff X` or a time window reads history only up to its base.
+- Imports that spell paths resolve through one rule — next to the importing
+  file, then from the root, `..` folded: Nim `import vendor/palette`, Nix
+  `import ../vendor/palette.nix` (and a directory's `default.nix`), Ruby
+  `require_relative`; OCaml `open Palette` links `palette.ml` (#285). A
+  TypeScript import resolves with the nearest `tsconfig*.json`, its relative
+  `extends` folded in, not only the root one (#372).
+- Plugin hook: `merge --squash`, `merge -S` and `cherry-pick -S` keep their
+  target; a pathspec commit previews the paths the index knows, never an
+  untracked file under them; `git apply`, `update-index`, `read-tree` and
+  the like before a commit preview the working tree; a step in another
+  repository stages nothing; the preview reads a copy of the index, so a
+  held index lock neither blocks it nor is taken; a first commit is checked
+  once it lands; a manual run that found nothing leaves no reminder;
+  `git status && git diff --cached` reviews the index; the `impact_gate`
+  option no longer silences PostToolUse answers; merging the branch's own
+  upstream (`git merge --ff-only origin/main`) is silence.
+- Impact: a definition moved to another module names the importers of the
+  old one; removed methods are found in classes split into fragments, and
+  `def self.x`, `func (r T) x`, `const x = () =>` name `x`; a deletion below
+  a definition does not change it; a lexical test or caller link stops at
+  a sibling project's manifest; a function nested in another has callers
+  only inside it, and an untyped `x.name` attribute read is no possible
+  caller. Formatting-only detection keeps a docstring
+  that is not one, and no longer calls a change layout when it moves a line
+  out of its Python or YAML block, drops a one-element tuple's comma, edits
+  a mid-word `#` (`${#a}`), or removes a `;` before a line starting with `(`
+  or `[` in JS/TS. Compatible extension requires the new field to be
+  appended, and a relative path to a moved file is a stale reference.
+- `--symbol` accepts `Owner.name`, `Owner::name` and dotted names; a
+  malformed one exits 2 in both CLIs, and over MCP a malformed or unknown
+  symbol is a refusal the agent can read, not "Error executing tool"; a
+  name in more than 256 files keeps its definition past the cap.
+- The Python budget fitter drops a `layout` witness with `mechanical` ones
+  and ranks `unknown` with content, as the native CLI does.
+- Release: post-publish smokes wait until both pip and uv resolve the version
+  and fail with a named error after 10 minutes; dispatched runs are found by
+  dispatch time (#364).
+- Plugin hook: a path git cannot hash (an untracked nested repository, a
+  moved submodule) no longer turns the answer into silence logged as
+  "clean"; a multi-commit cherry-pick touching a non-UTF-8 file is reviewed;
+  a `cd` that a search printed is not taken for where it ran. `--diff staged`
+  writes a copy of the index, so a held `index.lock` is no "unmerged entries?".
+- Impact: a Rust type and its `impl` blocks are one definition with its
+  callers, a trait method is reached through its trait (`Display`, not
+  `std`), and an unresolved name counts definitions, not "files" (#403).
+  Python `//` hides no call; a root `"baseUrl": "."` resolves bare
+  specifiers and overlapping `paths` take the longest prefix (#414). A
+  non-ASCII path, a `diff.context` setting, a deleted call statement, a
+  deletion right under a caller, a column-0 line removed from a body and a
+  call still naming a moved Rust function's old module no longer hide or
+  invent callers; a body call gaining an argument and an added `__slots__`
+  are not signature-compatible; `pub mod r#type;` and an attributed
+  `pub mod` are public; a same-language sibling module importing the
+  qualified name keeps its test link. `--symbol Owner.name` answers only for
+  that owner, and `PATH:Owner::name` parses. A call spread into an object
+  (`...workboxPolicy({..})`) is a call, not a member access: four Vite
+  configs read as zero callers.
+- Impact counts the files the run withholds instead of reading them as
+  nothing: the header says `N more withheld by ignore rules` for a range and
+  `N file(s) naming it withheld` for `--symbol`, and that their calls and
+  tests were not read (`withheld_files` in the JSON) (#392).
+- Impact: a definition moved within its file with its text unchanged lists
+  no callers, as a formatting-only edit does; moved and edited, it still
+  does. `@value.setter`, `@attr.s`, `@define`, `@enum.unique` and Lombok
+  annotations shape a definition and register it nowhere, so an untested
+  setter reads untested instead of "registered by" (#414).
+- The CLI and the MCP server report only the engine's own "nothing defines
+  it" as a refusal; a `KeyError` or `IndexError` is an internal error with its
+  traceback. Git output is decoded as UTF-8 on every platform.
+
 ## [1.18.3] - 2026-10-04
 
 ### Added
@@ -1903,7 +2299,9 @@ 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.3...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
 [1.18.1]: https://github.com/nikolay-e/diffctx/compare/v1.18.0...v1.18.1

{diffctx-1.18.3 → 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.3"
+version = "1.19.0"
 dependencies = [
  "aho-corasick",
  "anyhow",
+ "brokk-tree-sitter-kotlin",
  "clap",
  "dunce",
  "glob",

diffctx-1.19.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: diffctx
+Version: 1.19.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Dist: pathspec>=0.11,<2.0
+Requires-Dist: black>=23.0.0,<27.0 ; extra == 'dev'
+Requires-Dist: charset-normalizer>=3.0,<4.0 ; extra == 'dev'
+Requires-Dist: coverage>=7.0,<8.0 ; extra == 'dev'
+Requires-Dist: hypothesis>=6.0,<7.0 ; extra == 'dev'
+Requires-Dist: import-linter>=2.0,<3.0 ; extra == 'dev'
+Requires-Dist: mypy>=1.0,<3.0 ; extra == 'dev'
+Requires-Dist: pre-commit>=3.0,<5.0 ; extra == 'dev'
+Requires-Dist: pygit2>=1.12,<2.0 ; extra == 'dev'
+Requires-Dist: pytest>=7.0,<10.0 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23,<2.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=3.0,<8.0 ; extra == 'dev'
+Requires-Dist: pytest-timeout>=2.1,<3.0 ; extra == 'dev'
+Requires-Dist: pytest-xdist>=3.0,<4.0 ; extra == 'dev'
+Requires-Dist: pyyaml>=6.0.2,<8.0 ; extra == 'dev'
+Requires-Dist: radon>=6.0,<7.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.4,<1.0 ; extra == 'dev'
+Requires-Dist: tiktoken>=0.9,<1.0 ; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0,<7.0 ; extra == 'dev'
+Requires-Dist: charset-normalizer>=3.0,<4.0 ; extra == 'full'
+Requires-Dist: anyio>=4.5,<5.0 ; extra == 'mcp'
+Requires-Dist: mcp>=2.3,<3 ; extra == 'mcp'
+Provides-Extra: dev
+Provides-Extra: full
+Provides-Extra: mcp
+License-File: LICENSE
+Summary: Selects the minimum code an LLM needs to review a git diff
+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://diffctx.com/
+Author-email: Nikolay Eremeev <nikolay.eremeev@outlook.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Author, https://nikolay-eremeev.com
+Project-URL: Changelog, https://github.com/nikolay-e/diffctx/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://diffctx.com/
+Project-URL: Homepage, https://diffctx.com/
+Project-URL: Issues, https://github.com/nikolay-e/diffctx/issues
+Project-URL: Paper, https://doi.org/10.5281/zenodo.18824579
+Project-URL: Repository, https://github.com/nikolay-e/diffctx
+
+# diffctx — what a git change reaches, and the code to review it
+
+[![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)
+[![npm](https://img.shields.io/npm/v/diffctx)](https://www.npmjs.com/package/diffctx)
+[![MCP Registry](https://img.shields.io/badge/MCP_Registry-io.github.nikolay--e%2Fdiffctx-blue)](https://registry.modelcontextprotocol.io/v0/servers?search=io.github.nikolay-e/diffctx)
+
+**diffctx tells an agent or a reviewer what a change reaches outside its
+diff** — the callers, the tests that reach them, the contracts it crosses —
+**and selects the code needed to understand it** under a token budget. Local,
+deterministic, no index, no model calls. Caller resolution is static and per
+language; where it cannot resolve, the answer says so instead of printing a
+zero.
+
+> Formerly published as `treemapper` — every command, flag, and API call works unchanged.
+
+## Install
+
+```bash
+# 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
+
+# any MCP client
+claude mcp add diffctx -- uvx --from 'diffctx[mcp]' diffctx-mcp
+
+# CLI, zero-install
+uvx diffctx . --diff HEAD~1
+```
+
+pipx, pip, cargo, npm, Docker, Scoop, other MCP clients and the Python API:
+[integrations](docs/product/integrations.md).
+
+## Usage
+
+```bash
+diffctx . --diff --mode impact          # uncommitted work: callers outside the diff, their tests, contracts
+diffctx . --symbol parse_config         # the same for a name, no change needed
+diffctx . --diff main...feature         # the code to review a branch, packed under the auto budget
+diffctx . --diff HEAD~1 --budget 12000  # the last commit, capped at 12k o200k tokens
+diffctx . --diff 24h --mode locate      # today's work as ranked JSON, no source bodies
+diffctx .                               # whole-tree export, Markdown
+```
+
+`--diff` takes a git range, `staged`, or a duration window ending now (`24h`,
+`90min`, `2w`). Every flag, default and exit code:
+[command-line reference](docs/product/cli.md).
+
+![diffctx demo](https://raw.githubusercontent.com/nikolay-e/diffctx/main/docs/demo/demo.gif)
+
+## How it compares
+
+Whole-repo packers export everything; code-graph servers answer queries
+against a maintained index. diffctx is **diff-seeded**: the input is a change,
+the output is what it touches and what explains it. Measured results, and when
+the other two fit better: [COMPARISON.md](COMPARISON.md).
+
+## More
+
+- [Documentation site](https://diffctx.com/) — the pipeline end to end
+- [Command-line reference](docs/product/cli.md) — rendered from `diffctx --help`
+- [Integrations](docs/product/integrations.md) — install, MCP clients, Python API
+- [FAQ](docs/product/faq.md) — heuristic or oracle, ignore rules, monorepos, secrets
+- [Token counting](docs/product/token-budget.md) — `--budget` for non-GPT models
+- [GitHub Action](docs/product/github-action.md) — diff context as a CI step
+- [Benchmarks](BENCHMARKS.md) and the [paper](https://doi.org/10.5281/zenodo.18824579)
+- [Changelog](CHANGELOG.md) · [Security](SECURITY.md)
+- [Parameter strategy](docs/engineering/parameter-strategy.md)
+
+Apache 2.0
+
+<!-- mcp-name: io.github.nikolay-e/diffctx -->
+<!-- Ownership marker read from the PyPI description by the MCP registry. -->
+<!-- Must survive edits verbatim: one space after the colon, case-sensitive. -->
+