Skip to content
Back to search

ast-index-marketplace

MarketplaceWorks with Claude CodeGitHub

Plugins for Android/Kotlin/Java, iOS/Swift/ObjC, Dart/Flutter, TypeScript/JavaScript, Rust, Ruby, C#, PHP, Python, Go, Perl, Proto, WSDL, and C++ development

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/defendend--claude-ast-index-search/badge.svg)](/listings/defendend--claude-ast-index-search)

HTML

<a href="/listings/defendend--claude-ast-index-search"><img src="/api/listings/defendend--claude-ast-index-search/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Homebrew (macOS/Linux)

brew tap defendend/ast-index
brew install ast-index

Cargo (crates.io)

Requires a Rust toolchain.

cargo install ast-index --locked

To build the unreleased default branch instead:

cargo install --locked --git https://github.com/defendend/Claude-ast-index-search ast-index

Both build from source. For prebuilt release binaries, use Homebrew, npm, or Winget.

Winget (Windows)

winget install --id defendend.ast-index

Migration from kotlin-index

If you have the old `kotlin-index` installed:

brew uninstall kotlin-index
brew untap defendend/kotlin-index
brew tap defendend/ast-index
brew install ast-index

From source

git clone https://github.com/defendend/Claude-ast-index-search.git
cd Claude-ast-index-search
cargo build --release
# Binary: target/release/ast-index (~50 MB)

Troubleshooting: Syntax errors on install

If `brew install ast-index` fails with merge conflict errors (`<<<<<<< HEAD`), reset your local tap:

cd /opt/homebrew/Library/Taps/defendend/homebrew-ast-index
git fetch origin
git reset --hard origin/main
brew install ast-index

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 21 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "ast-index-marketplace",
  4. "description": "Plugins for Android/Kotlin/Java, iOS/Swift/ObjC, Dart/Flutter, TypeScript/JavaScript, Rust, Ruby, C#, PHP, Python, Go, Perl, Proto, WSDL, and C++ development",
  5. "owner": {
  6. "name": "defendend"
  7. },
  8. "plugins": [
  9. {
  10. "name": "ast-index",
  11. "description": "Fast code search for Android/Kotlin/Java, iOS/Swift/ObjC, Dart/Flutter, TypeScript/JavaScript, Rust, Ruby, C#, PHP, Python, Go, Perl, C++, Protocol Buffers, and WSDL/XSD projects",
  12. "author": {
  13. "name": "defendend"
  14. },
  15. "version": "3.56.0",
  16. "category": "development",
  17. "homepage": "https://github.com/defendend/Claude-ast-index-search",
  18. "source": "./plugin"
  19. }
  20. ]
  21. }
README.md · README · 1,397 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # ast-index v3.56.0
  2. Structural, AST-aware code navigation CLI for large, multi-language
  3. repositories. It builds a local SQLite index of symbols, references, imports,
  4. modules, dependencies, and inheritance so humans and agents can move through
  5. code by exact structure instead of grep-style text matches.
  6. https://t.me/defendend_ai_dev
  7. ## What It Gives You
  8. - Navigate classes, functions, files, imports, usages, callers, implementations,
  9. inheritance, modules, and dependency paths.
  10. - Start broad with `explore`, then jump to exact definitions with `symbol`,
  11. `class`, `outline`, and `refs`.
  12. - Keep the index current with `ast-index update` after the first `rebuild`.
  13. - Give coding agents compact, parseable context instead of raw file dumps.
  14. - Save ~40-50% of agent tokens on large repositories by returning structural
  15. slices of code instead of whole files.
  16. **Languages:** Kotlin, Java, Swift, Objective-C, TypeScript, JavaScript, Vue,
  17. Svelte, CSS, SCSS, Less, Rust, Zig, C#, Python, Go, C, C++, Scala, PHP, Ruby,
  18. Perl, Dart, Protocol Buffers, WSDL, XSD, BSL (1C:Enterprise), Lua, Bash, Elixir,
  19. SQL, R, Matlab, Groovy, Common Lisp, GDScript. Project type is auto-detected.
  20. ## How To
  21. ```bash
  22. # Install
  23. brew tap defendend/ast-index
  24. brew install ast-index
  25. # Build an index once per project
  26. cd /path/to/project
  27. ast-index rebuild
  28. # Ask code questions
  29. ast-index explore "payment flow"
  30. ast-index search ViewModel
  31. ast-index class BaseFragment
  32. ast-index usages Repository
  33. ast-index implementations Presenter
  34. ast-index deps app
  35. # Opt-in data: Git history and the symbol graph (neither runs on rebuild/update)
  36. ast-index hotspots --collect # rank files by churn, fixes, authors
  37. ast-index graph build # symbol-to-symbol dependency graph
  38. ast-index graph dependents ApplicationService # who depends on it, before a change
  39. ast-index search Service --rank proven # which match is safe to copy
  40. ```
  41. Use `ast-index update` after edits or branch switches. Hooks can queue a
  42. trailing-debounced refresh without losing edits that arrive during an update:
  43. ```bash
  44. ast-index update --background --debounce-ms 500
  45. ```
  46. Index-reading commands wait (with a bounded timeout) for an already queued
  47. generation, so they do not observe stale results. In monorepos with nested
  48. project markers, add `--walk-up` or `AST_INDEX_WALK_UP=1` to reuse the root
  49. index.
  50. **Guides:** [User guide](https://github.com/defendend/Claude-ast-index-search/blob/main/USER_GUIDE.md)
  51. for everyday workflow;
  52. [command setup guide](https://github.com/defendend/Claude-ast-index-search/blob/main/docs/setup-guide.md)
  53. for install/options/examples;
  54. [CodeGraph comparison](https://github.com/defendend/Claude-ast-index-search/blob/main/docs/comparison.md)
  55. for a dated, source-backed feature comparison.
  56. ## Performance
  57. Benchmarks on large Android project (~29k files, ~300k symbols):
  58. | Command | ast-index | grep | Speedup |
  59. |---------|-----------|------|---------|
  60. | imports | 0.3ms | 90ms | **260x** |
  61. | dependents | 2ms | 100ms | **100x** |
  62. | deps | 3ms | 90ms | **90x** |
  63. | class | 1ms | 90ms | **90x** |
  64. | search | 11ms | 280ms | **14x** |
  65. | usages | 8ms | 90ms | **12x** |
  66. ## Installation
  67. ### Homebrew (macOS/Linux)
  68. ```bash
  69. brew tap defendend/ast-index
  70. brew install ast-index
  71. ```
  72. ### Cargo (crates.io)
  73. Requires a Rust toolchain.
  74. ```bash
  75. cargo install ast-index --locked
  76. ```
  77. To build the unreleased default branch instead:
  78. ```bash
  79. cargo install --locked --git https://github.com/defendend/Claude-ast-index-search ast-index
  80. ```
  81. Both build from source. For prebuilt release binaries, use Homebrew, npm, or Winget.
  82. ### Winget (Windows)
  83. ```shell
  84. winget install --id defendend.ast-index
  85. ```
  86. ### Migration from kotlin-index
  87. If you have the old `kotlin-index` installed:
  88. ```bash
  89. brew uninstall kotlin-index
  90. brew untap defendend/kotlin-index
  91. brew tap defendend/ast-index
  92. brew install ast-index
  93. ```
  94. ### From source
  95. ```bash
  96. git clone https://github.com/defendend/Claude-ast-index-search.git
  97. cd Claude-ast-index-search
  98. cargo build --release
  99. # Binary: target/release/ast-index (~50 MB)
  100. ```
  101. ### Troubleshooting: Syntax errors on install
  102. If `brew install ast-index` fails with merge conflict errors (`<<<<<<< HEAD`), reset your local tap:
  103. ```bash
  104. cd /opt/homebrew/Library/Taps/defendend/homebrew-ast-index
  105. git fetch origin
  106. git reset --hard origin/main
  107. brew install ast-index
  108. ```
  109. ## Monorepo Workflow
  110. If your repo has subdirectories with their own VCS markers (git submodules,
  111. subtrees, nested `Cargo.toml` / `settings.gradle`), read-commands normally
  112. stop at the nearest marker — they won't reuse a parent-level index even
  113. if one exists. Pass `--walk-up`, or set `AST_INDEX_WALK_UP=1`, to tell
  114. the lookup to prefer any existing parent DB over nested markers:
  115. ```bash
  116. # once, in the root
  117. cd /monorepo && ast-index rebuild
  118. # later, from any subproject — reuse the root index
  119. AST_INDEX_WALK_UP=1 ast-index search ViewModel
  120. # or per-call:
  121. ast-index --walk-up search ViewModel
  122. ```
  123. This is opt-in by design: silently preferring a far-away parent DB could
  124. surface a stale or misconfigured index from an earlier accidental
  125. `rebuild` higher up. With the flag you explicitly say "trust the parent".
  126. ## Worktrees And Intentional Cross-Root Workspaces
  127. Independent git worktrees get independent indexes because their canonical
  128. root paths differ. Rebuild once inside each worktree; do not attach worktrees
  129. to one another.
  130. For source trees that intentionally form one workspace, create the primary
  131. index first, attach a named subtree, then index the attached files:
  132. ```bash
  133. cd /path/to/application
  134. ast-index rebuild
  135. ast-index subtree add shared ../shared-library
  136. ast-index update # or: ast-index rebuild
  137. ast-index subtree list
  138. ```
  139. Use `--subtree shared` to query only that attachment and `--local` to query
  140. only the primary project. The legacy root commands remain compatibility
  141. aliases; new automation should use `subtree add/remove/list`.
  142. ## AI Agent Integration
  143. ### Claude Code Plugin
  144. ```bash
  145. # Option 1: via marketplace
  146. claude plugin marketplace add defendend/Claude-ast-index-search
  147. claude plugin install ast-index
  148. # Option 2: if ast-index is already installed
  149. ast-index install-claude-plugin
  150. ```
  151. Restart Claude Code to activate.
  152. Update: `brew upgrade ast-index && claude plugin update ast-index`.
  153. Uninstall: `claude plugin uninstall ast-index`.
  154. The Claude plugin ships `/initialize` as the default setup command. It
  155. auto-detects project stack(s), including KMP and polyglot repos, then writes
  156. `.claude/settings.json` and `.claude/rules/ast-index.md`. Use
  157. `/initialize-android`, `/initialize-ios`, `/initialize-web`, `/initialize-rust`,
  158. `/initialize-csharp`, or `/initialize-ruby` only as manual overrides.
  159. See [`examples/.claude/rules/ast-index.md`](examples/.claude/rules/ast-index.md)
  160. for a template rules file that teaches the agent to use ast-index for
  161. structural navigation, outline before reading large files, and pass the same
  162. instructions to subagents. Adapt before dropping into your project's
  163. `.claude/rules/`.
  164. ### Codex Skill / Plugin
  165. Codex can use the shared `ast-index` skill directly. For local development,
  166. symlink or copy the skill directory into Codex's global skills directory:
  167. ```bash
  168. mkdir -p ~/.codex/skills
  169. ln -s /absolute/path/to/Claude-ast-index-search/plugin/skills/ast-index ~/.codex/skills/ast-index
  170. ```
  171. This repository also includes a Codex plugin manifest at
  172. [`plugin/.codex-plugin/plugin.json`](plugin/.codex-plugin/plugin.json) and a
  173. repo marketplace at [`.agents/plugins/marketplace.json`](.agents/plugins/marketplace.json)
  174. for Codex builds that support plugin marketplaces.
  175. If your Codex build supports plugin marketplaces, restart Codex in this repo
  176. and install `ast-index` from the repo marketplace. For a remote marketplace,
  177. add the repository:
  178. ```bash
  179. codex plugin marketplace add defendend/Claude-ast-index-search
  180. ```
  181. The Codex package exposes the same `ast-index` skill. Command-style project
  182. setup is kept out of the Codex manifest because Codex uses skills and local
  183. project configuration as first-class components.
  184. ### Cursor Skill / Plugin
  185. Cursor can use the shared skill directly:
  186. ```bash
  187. mkdir -p ~/.cursor/skills
  188. ln -s /absolute/path/to/Claude-ast-index-search/plugin/skills/ast-index ~/.cursor/skills/ast-index
  189. ```
  190. This repository also includes a Cursor plugin manifest at
  191. [`plugin/.cursor-plugin/plugin.json`](plugin/.cursor-plugin/plugin.json) and a
  192. multi-plugin marketplace at [`.cursor-plugin/marketplace.json`](.cursor-plugin/marketplace.json).
  193. For local Cursor testing:
  194. ```bash
  195. mkdir -p ~/.cursor/plugins/local
  196. ln -s /absolute/path/to/Claude-ast-index-search/plugin ~/.cursor/plugins/local/ast-index
  197. ```
  198. Reload Cursor after creating the symlink. The Cursor plugin package exposes the
  199. shared `ast-index` skill, a project rule in `plugin/rules/`, and a Cursor-specific
  200. `initialize-ast-index` command that writes `.cursor/rules/ast-index.mdc`.
  201. ### Gemini CLI
  202. ```bash
  203. gemini skills install https://github.com/defendend/Claude-ast-index-search.git --path plugin/skills/ast-index
  204. ```
  205. ## 💝 Support Development
  206. [![Support on Boosty](https://img.shields.io/badge/Support%20on-Boosty-FF5722?style=for-the-badge&logo=star)](https://boosty.to/ast_index/donate)
  207. ---
  208. ## Commands (47+)
  209. Run `ast-index rebuild` once per project, then use `ast-index update` to keep
  210. the index fresh.
  211. ```bash
  212. ast-index explore <QUERY...> # One-shot context: ranked symbols, outline/source, neighbours, tests (--rwr for graph)
  213. ast-index search <QUERY> # Universal structural search
  214. ast-index search <QUERY> --rank <PRESET> # Re-rank by history + graph: proven, hotspots, risky, central
  215. ast-index file <PATTERN> # Find files
  216. ast-index symbol <NAME> # Find symbols
  217. ast-index symbol <NAME> --with-content # Include matched symbol bodies
  218. ast-index search <QUERY> --with-content # Include matched symbol bodies
  219. ast-index class <NAME> # Find classes/interfaces
  220. ast-index outline <FILE> # Symbols in file
  221. ast-index imports <FILE> # Imports in file
  222. ast-index refs <SYMBOL> # Definitions + imports + usages
  223. ast-index usages <SYMBOL> # Symbol usages
  224. ast-index callers <FUNCTION> # Function call sites
  225. ast-index implementations <PARENT> # Find implementations
  226. ast-index implementations <PARENT> --with-content # Include implementation bodies
  227. ast-index hierarchy <CLASS> # Class hierarchy tree
  228. ast-index changed [--base BRANCH] # Branch-level changed files (A/M/D/R)
  229. ast-index hotspots [--collect] # Rank files by Git history (churn, fixes, authors)
  230. ast-index graph <SUBCOMMAND> # Symbol graph: build, dependents, impact, path, cycles, top, metrics
  231. ast-index todo [PATTERN] # TODO/FIXME/HACK comments
  232. ast-index deprecated [QUERY] # Deprecated items
  233. ```
  234. ### Paginated JSON schema v2
  235. Limited search commands now report completeness explicitly. `symbol`, `class`,
  236. `implementations`, `usages`, and `callers` use this shape:
  237. ```json
  238. {
  239. "schema_version": 2,
  240. "items": [],
  241. "pagination": {
  242. "total": 0,
  243. "returned": 0,
  244. "truncated": false,
  245. "limit": 50
  246. }
  247. }
  248. ```
  249. For `symbol --with-content` and `implementations --with-content`, each item
  250. additionally contains `content`, `truncated`, and `end_line`. `content` is a
  251. line-numbered source body read from disk, capped at 60 lines; `truncated` tells
  252. whether the range extends past those lines, and `end_line` is the indexed end
  253. of the symbol. `search --with-content` adds the same fields to its `symbols`
  254. array, including ranked search. Text output marks truncated bodies. Without
  255. the flag, response shapes are unchanged. The index stores parser supplied
  256. start and end lines, not body text. Existing indexes gain ranges as files are
  257. reindexed; `rebuild` fills them immediately.
  258. `search` and `refs` keep their named result arrays and provide one pagination
  259. object per array under `pagination`. Consumers migrating from bare arrays must
  260. read `items` for single-result-set commands and must check `truncated` before
  261. treating a response as complete. This is limit-based pagination, not a cursor:
  262. rerun with a larger `--limit` when more results are required.
  263. The cache-independent `changed` command retains its separate JSON schema v1;
  264. its schema version did not change with this pagination migration.
  265. ### Changed files on the current branch
  266. `changed` asks the detected version-control repository for the files changed from
  267. `merge-base(base, HEAD)` to `HEAD`. Without `--base`, Git resolves
  268. `origin/HEAD`, then tries `origin/main`, `origin/master`, `main`, `master`, and
  269. `trunk`; other supported backends select their conventional mainline. It reads
  270. version-control state directly, so it works without an
  271. ast-index database and does not require `rebuild` or `update`. Results are
  272. scoped to the current working directory, while paths remain
  273. repository-relative. Staged and unstaged working-tree edits are not included.
  274. ```bash
  275. # Compact text summary
  276. ast-index changed
  277. # Stable schema v1; the VCS timeout defaults to 30000 ms
  278. ast-index --format json changed --base origin/main --timeout-ms 30000
  279. # Print the detected root, scope, exact VCS argv, and timing to stderr
  280. ast-index changed --verbose
  281. ```
  282. Text output uses `A` (added), `M` (modified), `D` (deleted), and `R` (renamed):
  283. ```text
  284. Changed files against origin/main (3):
  285. M README.md
  286. R docs/old-guide.md -> docs/setup-guide.md
  287. M docs/generated\nname.md
  288. ```
  289. Control characters and backslashes in text paths are escaped, so every change
  290. stays on one output line. Use JSON instead of parsing this human-readable
  291. summary in scripts.
  292. JSON output preserves rename metadata:
  293. ```json
  294. {
  295. "schema_version": 1,
  296. "vcs": "git",
  297. "base": "origin/main",
  298. "head": "HEAD",
  299. "scope": null,
  300. "changes": [
  301. { "status": "M", "path": "README.md" },
  302. { "status": "R", "path": "docs/setup-guide.md", "old_path": "docs/old-guide.md" }
  303. ]
  304. }
  305. ```
  306. At the repository root, `scope` is `null`; from a nested working directory it
  307. is that repository-relative directory path.
  308. This is a fast file summary for branch review, not a changed-symbol report and
  309. not a replacement for your version-control system's diff command when patch
  310. hunks are needed.
  311. ### Git hotspots
  312. Two files can look equally good to copy from and have very different histories:
  313. one absorbed 28 commits in six months with 54% of them bugfixes, the other was
  314. written once and left alone for 86 days. `hotspots` puts that history next to
  315. the code.
  316. Per file, collected from the Git log: commit count, churn (added + deleted
  317. lines, plus churn relative to the file's current size), bugfix share, distinct
  318. author count, age of the first commit, and time since the last change.
  319. Thresholds are **percentiles within this repository**, not constants. 28
  320. commits is a lot for a small library and unremarkable in a monorepo, so
  321. `churn:high` means p90+ *here*. Raw numbers are always printed next to the
  322. label.
  323. ```bash
  324. # Collect history into the index, then show the top 20
  325. ast-index hotspots --collect
  326. # Report from already-collected data (no Git subprocess at all)
  327. ast-index hotspots --limit 50 --sort fixes
  328. # Narrow to a directory; percentiles still come from the whole repository
  329. ast-index hotspots --path src/parsers --min-commits 5
  330. # Discard the cursor and rescan the full history
  331. ast-index hotspots --collect --full
  332. # Stable paginated schema v2
  333. ast-index --format json hotspots --limit 10
  334. ```
  335. Collection is **never implicit**: `rebuild` and `update` do not run it, so
  336. indexing cost is unchanged for everyone who does not ask for this. The first
  337. `--collect` walks the whole history; every later one reads only what changed.
  338. History is stored per commit, so a branch switch, rebase, force-push or reset
  339. subtracts the commits `HEAD` no longer reaches and adds the new ones, and the
  340. numbers equal a fresh full collection at that `HEAD`. Line counts come from the
  341. working tree: an uncommitted edit counts once a later `--collect` recomputes
  342. that file (a commit or checkout changes it) or on `--full`.
  343. Signals live in their own tables, keyed by project-relative path, so they
  344. also cover files the parsers never look at (fixtures, configs, migrations).
  345. They depend on the repository, not on the index, so `rebuild` carries them
  346. into the new index and the next `--collect` stays incremental. It leaves them
  347. behind, says so, and the next `--collect` reads the history again only when
  348. they were collected by an older version or from another working tree or
  349. scope, or cannot be read back intact.
  350. ```text
  351. Git hotspots — 289 file(s) with history, 370 commit(s) analyzed, HEAD 50db069dbb, sorted by score:
  352. Labels are percentiles within this repository (high = p90+, elevated = p75+).
  353. src/indexer.rs
  354. score 90 · commits 70 (p98) · fixes 17/70 = 24% (p72) · churn +8558/-3259 (p99, 2.2x file)
  355. authors 6 (p99) · age 244d · last change 0d ago · 5298 lines
  356. churn:high rewritten-often authors:many veteran
  357. ```
  358. Labels: `churn:high` / `churn:elevated`, `rewritten-often` (high churn per
  359. current line, only for files of 10+ lines), `fixes:high` / `fixes:elevated`
  360. (only for files with at least four commits, so 1-of-1 is never "100% bugs"),
  361. `authors:many`, `veteran`. `score` is the mean of the commit, churn and
  362. bugfix-ratio percentiles.
  363. Bugfix detection is a heuristic over commit subjects: leading tracker keys
  364. (`[ABC-123]`, `ABC-123:`, `#42`, `[ABC-1][ABC-2]`) are stripped first, then
  365. English and Russian bugfix vocabulary is matched on word boundaries — so
  366. `prefix` is not a fix, `Исправить падение` is, and so is `[HOTFIX][ABC-123]`
  367. (only keys are stripped, not tags like `[HOTFIX]` or `[FIX]`). Merge commits
  368. are excluded. Renames follow the file: history recorded under the old path
  369. moves onto the new one.
  370. `--sort` accepts `score` (default), `commits`, `churn`, `relative-churn`,
  371. `fixes`, `authors`, `recent`. `fixes` orders by the bugfix share discounted
  372. for thin history — the lower bound of its 95% Wilson interval, so 11 fixes in
  373. 17 commits rank above 2 in 2 — and lists files with fewer than four commits
  374. after the rest. `--subtree` is rejected: the signals describe the project's own
  375. working tree.
  376. ### Symbol graph and ranked search
  377. `graph build` turns indexed references into symbol-to-symbol edges, each with
  378. the confidence of its resolution (`local`, `scoped`, `import`, `unique`,
  379. `ambiguous`). Like history collection it is explicit: `rebuild` and `update`
  380. never run it, and queries flag a graph gone stale (`--refresh` rebuilds first).
  381. ```bash
  382. ast-index graph build
  383. ast-index graph dependents ApplicationService # incoming edges
  384. ast-index graph impact PaymentGateway --depth 3 # transitive dependents per hop
  385. ast-index graph path OrdersController Invoice # how one reaches the other
  386. ast-index graph top --kind class --exclude-tests # most central symbols
  387. ```
  388. `search --rank <preset>` re-orders the Files and Symbols of a search by the
  389. collected Git history and the graph: `proven` (safe to copy), `hotspots`
  390. (keeps being fixed), `risky` (many dependents and unstable history), `central`
  391. (PageRank). Exact name matches stay first; a preset whose data is missing is
  392. not applied and the output names the command that collects it. Formulas and
  393. their backtest are in the
  394. [user guide](USER_GUIDE.md#ranking-search-results-by-history-and-structure).
  395. ### Module analysis
  396. ```bash
  397. ast-index module <PATTERN> # Find modules
  398. ast-index deps <MODULE> # Module dependencies
  399. ast-index dependents <MODULE> # Dependent modules
  400. ast-index unused-deps <MODULE> # Find unused dependencies (v3.2: +transitive, XML, resources)
  401. ast-index api <MODULE> # Public API of module
  402. ```
  403. #### module-route — dependency path between two modules
  404. Show how module A reaches module B through the dependency graph:
  405. ```bash
  406. # Shortest path (default)
  407. ast-index module-route --from core.utils --to features.payments.api
  408. # All simple paths, filtered to api edges only
  409. ast-index module-route --from app --to core.db --all --via-kind api
  410. # JSON output — machine-readable, no ANSI
  411. ast-index module-route --from app --to core.db --format json
  412. # Mermaid diagram (paste into any markdown renderer)
  413. ast-index module-route --from app --to core.db --format mermaid
  414. # Graphviz DOT
  415. ast-index module-route --from app --to core.db --format dot
  416. # Gradle-style module names work too
  417. ast-index module-route --from :app --to :core:utils
  418. ```
  419. Options:
  420. - `--all` — return all simple paths instead of the single shortest
  421. - `--via-kind <api|implementation|all>` — filter traversal to one edge kind (default: `all`)
  422. - `--max-paths <N>` — cap on returned paths when `--all` is set (default: 50)
  423. - `--max-depth <N>` — cap on path length in hops (default: 20)
  424. - `--timeout-ms <N>` — wall-clock guard in milliseconds (default: 5000)
  425. ### XML & Resource analysis
  426. ```bash
  427. ast-index xml-usages <CLASS> # Find class usages in XML layouts
  428. ast-index resource-usages <RES> # Find resource usages (@drawable/ic_name, R.string.x)
  429. ast-index resource-usages --unused --module <MODULE> # Find unused resources
  430. ```
  431. ### iOS-specific commands
  432. ```bash
  433. ast-index storyboard-usages <CLASS> # Class usages in storyboards/xibs
  434. ast-index asset-usages [ASSET] # iOS asset usages (xcassets)
  435. ast-index asset-usages --unused --module <MODULE> # Find unused assets
  436. ast-index swiftui [QUERY] # @State/@Binding/@Published props
  437. ast-index async-funcs [QUERY] # Swift async functions
  438. ast-index publishers [QUERY] # Combine publishers
  439. ast-index main-actor [QUERY] # @MainActor usages
  440. ```
  441. ### Perl-specific commands
  442. ```bash
  443. ast-index perl-exports [QUERY] # Find @EXPORT/@EXPORT_OK
  444. ast-index perl-subs [QUERY] # Find subroutines
  445. ast-index perl-pod [QUERY] # Find POD documentation (=head1, =item, etc.)
  446. ast-index perl-tests [QUERY] # Find Test::More assertions (ok, is, like, etc.)
  447. ast-index perl-imports [QUERY] # Find use/require statements
  448. ```
  449. ### Index management
  450. ```bash
  451. ast-index rebuild [--type TYPE] # Full reindex
  452. ast-index update # Incremental update
  453. ast-index stats # Index statistics
  454. ast-index version # Version info
  455. ```
  456. ## Language-Specific Features
  457. ### TypeScript/JavaScript (new in v3.9)
  458. Supported elements:
  459. - Classes, interfaces, type aliases, enums
  460. - Class methods (constructor, getters/setters, static, async)
  461. - Class fields/properties, private `#members`, abstract methods
  462. - Functions (regular, arrow, async)
  463. - React components and hooks (`useXxx`)
  464. - Vue SFC (`<script>` extraction)
  465. - Svelte components
  466. - Decorators (@Controller, @Injectable, etc.)
  467. - Namespaces, constants, imports/exports
  468. ```bash
  469. ast-index class "Component" # Find React/Vue components
  470. ast-index search "use" # Find React hooks
  471. ast-index search "@Controller" # Find NestJS controllers
  472. ast-index class "Props" # Find prop interfaces
  473. ```
  474. ### Rust (new in v3.9)
  475. Supported elements:
  476. - Structs, enums, traits
  477. - Impl blocks (`impl Trait for Type`)
  478. - Functions, macros (`macro_rules!`)
  479. - Type aliases, constants, statics
  480. - Modules, use statements
  481. - Derive attributes
  482. ```bash
  483. ast-index class "Service" # Find structs
  484. ast-index class "Repository" # Find traits
  485. ast-index search "impl" # Find impl blocks
  486. ast-index search "macro_rules" # Find macros
  487. ```
  488. ### Ruby (new in v3.9)
  489. Supported elements:
  490. - Classes, modules
  491. - Methods (def, def self.)
  492. - RSpec DSL (describe, it, let)
  493. - Rails patterns (has_many, validates, scope, callbacks)
  494. - Require statements, include/extend
  495. ```bash
  496. ast-index class "Controller" # Find controllers
  497. ast-index search "has_many" # Find associations
  498. ast-index search "describe" # Find RSpec tests
  499. ast-index search "scope" # Find scopes
  500. ```
  501. ### C# (new in v3.9)
  502. Supported elements:
  503. - Classes, interfaces, structs, records
  504. - Enums, delegates, events
  505. - Methods, properties, fields
  506. - ASP.NET attributes (@ApiController, @HttpGet, etc.)
  507. - Unity attributes (@SerializeField)
  508. - Namespaces, using statements
  509. ```bash
  510. ast-index class "Controller" # Find ASP.NET controllers
  511. ast-index class "IRepository" # Find interfaces
  512. ast-index search "[HttpGet]" # Find API endpoints
  513. ast-index search "MonoBehaviour" # Find Unity scripts
  514. ```
  515. ### Dart/Flutter (new in v3.10)
  516. Supported elements:
  517. - Classes with Dart 3 modifiers (abstract, sealed, final, base, interface, mixin class)
  518. - Mixins, extensions, extension types
  519. - Enhanced enums with implements/with
  520. - Functions, constructors, factory constructors
  521. - Getters/setters, typedefs, properties
  522. - Imports/exports
  523. ```bash
  524. ast-index class "Widget" # Find widget classes
  525. ast-index class "Provider" # Find providers
  526. ast-index search "mixin" # Find mixins
  527. ast-index implementations "State" # Find State implementations
  528. ast-index outline "main.dart" # Show file structure
  529. ast-index imports "app.dart" # Show imports
  530. ```
  531. ### Python
  532. ```bash
  533. ast-index class "ClassName" # Find Python classes
  534. ast-index symbol "function" # Find functions
  535. ast-index outline "file.py" # Show file structure
  536. ast-index imports "file.py" # Show imports
  537. ```
  538. ### Go
  539. ```bash
  540. ast-index class "StructName" # Find structs/interfaces
  541. ast-index symbol "FuncName" # Find functions
  542. ast-index outline "file.go" # Show file structure
  543. ast-index imports "file.go" # Show imports
  544. ```
  545. ## Configuration File
  546. Create `.ast-index.yaml` in your project root to configure ast-index:
  547. ```yaml
  548. # Additional directories to index
  549. roots:
  550. - "../shared-lib"
  551. - "../common-modules"
  552. # Directories to exclude from indexing
  553. exclude:
  554. - "vendor"
  555. - "build"
  556. - "node_modules"
  557. # Index only these directories (allow-list; everything else is skipped)
  558. include:
  559. - "app"
  560. - "packages/shared"
  561. # Include files ignored by .gitignore
  562. no_ignore: false
  563. ```
  564. All fields are optional. CLI flags override config file values.
  565. `include` and `exclude` from this file also scope the grep-based commands
  566. (`search` content matches, `todo`, `callers`, `usages` fallback and the rest),
  567. so a directory the index skips is not read by them either. The
  568. `rebuild --include` / `--exclude` flags apply to that one rebuild only and do
  569. not change what those commands scan.
  570. ### Examples
  571. **Monorepo with shared libraries:**
  572. ```yaml
  573. roots:
  574. - "../core"
  575. - "../network"
  576. ```
  577. **Project with generated code to skip:**
  578. ```yaml
  579. exclude:
  580. - "generated"
  581. - "proto/gen"
  582. ```
  583. ## Changelog
  584. ### 3.57.0
  585. - **Detect Python projects that have no `pyproject.toml`** — `detect-stacks`,
  586. `/initialize`, `stats` and `map` now recognise pip-tools / uv / pipenv /
  587. poetry projects by `Pipfile`, `Pipfile.lock` and `poetry.lock` anywhere in
  588. the tree, and by `requirements.txt`, `requirements.in`, `pytest.ini` and
  589. `tox.ini` at the project root. The root-only rule keeps a
  590. `docs/requirements.txt` in an Android or web project from turning it into
  591. a polyglot one, and a lone `.python-version` is not treated as Python.
  592. Contributed in [#74](https://github.com/defendend/Claude-ast-index-search/pull/74).
  593. - **`search` content matches now cover what the index covers** — the content
  594. scan walks attached subtrees as well as the primary root, and `--local` /
  595. `--subtree NAME` narrow it the same way they narrow indexed results.
  596. `include` and `exclude` from `.ast-index.yaml` now scope every grep-based
  597. command, so an excluded `vendor/` or generated directory is no longer read by
  598. `search`, `todo` and the others. Fixes
  599. [#67](https://github.com/defendend/Claude-ast-index-search/issues/67) and
  600. covers the search-scope part of
  601. [#62](https://github.com/defendend/Claude-ast-index-search/pull/62).
  602. ### 3.56.0
  603. This release merges the symbol graph, Git hotspots and ranked search work
  604. contributed in [#72](https://github.com/defendend/Claude-ast-index-search/pull/72)
  605. (which also carried [#28](https://github.com/defendend/Claude-ast-index-search/pull/28)),
  606. the `--with-content` responses from
  607. [#73](https://github.com/defendend/Claude-ast-index-search/pull/73), and
  608. follow-up fixes.
  609. - **`graph` — a symbol dependency graph** — `graph build` resolves indexed
  610. references into symbol-to-symbol edges and stores them with per-edge
  611. resolution confidence (`local`, `scoped`, `import`, `unique`, `ambiguous`).
  612. Queries on top of it: `dependents`, `dependencies`, `impact` (transitive
  613. dependents), `path`, `cycles`, `top`, `status` and `metrics` (fan-in, fan-out,
  614. PageRank). Ruby references resolve through namespaces, lexical nesting,
  615. constant receivers, inheritance and mixins; JavaScript/TypeScript references
  616. through the module's own imports. Metrics count resolved edges only and
  617. report ambiguous ones separately, so a name defined in hundreds of places
  618. does not inflate a symbol's centrality. The graph is opt-in: `rebuild` and
  619. `update` never build it, and queries flag a stale graph after the index
  620. changes and accept `--refresh`.
  621. - **`hotspots` — per-file Git history signals** — a new command ranks files by
  622. what their history says about them: commit count, churn (absolute and
  623. relative to the file's current size), bugfix share, distinct authors, age
  624. and time since the last change. Thresholds are percentiles *within the
  625. repository being indexed*, not absolute constants, so "high churn" means
  626. something in a 300-file library and in a 30 000-file monorepo alike; raw
  627. numbers are printed next to every label. Text and `--format json` output,
  628. paginated JSON schema v2.
  629. - **Collection is opt-in** — `rebuild` and `update` never walk the log;
  630. `hotspots --collect` does.
  631. - **`search --rank` — re-rank results by history and structure** — four
  632. presets re-order the Files and Symbols sections of a search: `proven` (calm,
  633. old, idle and actually used — safe to copy), `hotspots` (the file's hotspot
  634. score), `risky` (transitive dependents × hotspot score) and `central`
  635. (PageRank). Every result carries its dossier: the score and its terms, raw
  636. history and graph numbers with repository percentiles and labels, and the
  637. relevance position it came from. Relevance stays in charge: exact name
  638. matches stay above partial ones, the pool is the head of the plain order, and
  639. the preset only weighs in inside a tier. History is labelled as per-file,
  640. third-party code is never scored and goes last, and a preset whose data is
  641. missing is not applied — the output names `hotspots --collect` or
  642. `graph build` instead of ranking by zeros. Formulas were chosen by
  643. backtesting next-year bugfixes on a 40k-file monorepo.
  644. - **MCP exposes the symbol graph, Git hotspots and ranked search** — seven new
  645. tools: `graph_dependents` (direct dependents, or the transitive blast radius
  646. with `depth` ≥ 2), `graph_dependencies`, `graph_path`, `graph_metrics` (the
  647. most central symbols, or metrics of given ones), `graph_cycles`,
  648. `graph_build` and `hotspots`; `search` takes `rank` (`proven`, `hotspots`,
  649. `risky`, `central`). Descriptions tell the agent when to reach for each one —
  650. before changing a symbol, when choosing which match to copy — and what has to
  651. be collected first; graph queries accept `refresh: true` to build a missing or
  652. stale graph in place. History collection stays a CLI command, since its first
  653. run outlasts common MCP client timeouts, and the tools name it when history is
  654. missing. Output is compact text: a ranked search prints each file's history
  655. and each symbol's graph numbers once, about a quarter of the JSON size.
  656. - **`symbol`, `search` and `implementations` take `--with-content`** — each
  657. matched symbol is followed by its line-numbered source body, read from disk
  658. at the range the parser recorded (`end_line`), so an agent gets the
  659. definition in one call instead of a follow-up `sed`/`rg`. Bodies are capped
  660. at 60 lines; a longer one ends with `... truncated at line N; symbol ends at
  661. line M`, and JSON items carry `content`, `truncated` and `end_line`. Without
  662. the flag the output is unchanged. The MCP `symbol`, `search` and
  663. `implementations` tools accept `with_content: true`.
  664. - **Symbol ranges for every tree-sitter language** — `end_line` used to be
  665. filled only for Ruby and TypeScript/JavaScript, so `call-tree`,
  666. `explore --rwr` and `graph` fell back to "the last definition above the
  667. line" everywhere else. Python, Go, Rust, Java, Kotlin, Swift, C#, C/C++, PHP,
  668. Scala, Dart, Lua, Elixir, Zig, Objective-C, Groovy, Bash, SQL, R, MATLAB,
  669. GDScript, Common Lisp, BSL and Protobuf now store the last line of every
  670. definition, with classes, modules and namespaces enclosing their members.
  671. The fallback had blamed the wrong definition for 3.6% of references in a Rust
  672. codebase, 11% in a Go checkout and 18–42% in C++; module-level code no longer
  673. gets an invented caller. Decorators and annotations stay outside the
  674. definition they decorate, since they run in the enclosing scope. The graph
  675. treats Rust `impl` blocks and Swift/Objective-C extensions as the namespace of
  676. the type they extend, so `Type::new(…)` and `Self::helper(…)` resolve. CSS,
  677. SCSS, Less and the regex-based parsers still report no ranges. Run
  678. `ast-index rebuild` to fill ranges in an existing index.
  679. - **`outline` prints line ranges and supports `--format json`** —
  680. `:12-40 Invoice [class]`, rows in source order, JSON schema v1 with
  681. `end_line`.
  682. - **Tell code from prose by the syntax tree** — names in comments, docstrings
  683. and string literals are no longer references in Ruby, Python, JS/TS, C/C++,
  684. Objective-C, Go, Rust, Java, C#, PHP, Swift, Scala, Dart, Lua, Groovy,
  685. Elixir, Bash, R, Zig and Proto. Interpolated code stays, and so do strings
  686. that name code: Ruby constant-path strings and `%w[]` words
  687. (`class_name: 'Invoice'`), Python dotted class names (`"pkg.models.User"`),
  688. JS `import('./Page')`. References drop 7–51% per project.
  689. - **`rebuild` is about 40% faster** — signatures looked up their source line
  690. by scanning the file from the top for every symbol (quadratic in file
  691. length) and copied the whole line before truncating it; Ruby and TypeScript
  692. files were parsed twice (symbols, then references); and parse threads sat
  693. idle while each chunk was written. Lines are now indexed once per file,
  694. signatures capped before copying, each file parsed once, and writing
  695. overlaps parsing in the same order, so the index is byte-for-byte the same:
  696. 9.3 → 5.5 s on a 40k-file monorepo.
  697. - **`update` finds changes 3–4× faster** — the project root was canonicalized
  698. once per file (a thread and a `realpath` each), and files were stat'ed and
  699. `node_modules` packages walked one by one; now once per walk and in
  700. parallel. A no-op `update` on a 40k-file project: 2.1 → 0.6 s; 20 changed
  701. files: 1.8 → 0.4 s.
  702. - **Minified JavaScript and CSS are left out** — `.js` / `.mjs` / `.cjs` /
  703. `.css` files named `*.min.*` or `*-min.*`, or whose first 64 KiB is minifier
  704. output (lines of 1000+ bytes on average, 100+ of them outside string
  705. literals), are no longer indexed, read by the grep-based commands (`search`
  706. contents, `callers`, `call-tree`, `todo`, …) or parsed by `outline` /
  707. `imports`, which now say the file was skipped. A one-line stylesheet gave
  708. each of its thousands of selectors the whole file as a signature: on a Rails
  709. monorepo with a 589 KB `app.min.css`, `outline` of that file took 4.6 GB and
  710. `rebuild` peaked at 4–7 GB; now 11 MB and 0.21 GB. `callers` / `call-tree`
  711. no longer answer from bundles (`__webpack_require__`). Source with a few long
  712. strings, SVG paths or data URIs is unaffected, and TypeScript, JSX, SCSS and
  713. `.d.ts` are never judged. `update` drops minified files an older index kept,
  714. without a rebuild. `AST_INDEX_SKIP_MINIFIED=0` turns the filter off.
  715. - **Rust `use` declarations count as references again** — `use
  716. crate::models::Widget;` is the first use of `Widget` in a file, not the
  717. declaration of its own last segment; `usages` and `refs` list import lines
  718. for Rust projects as before. Takes effect on the next `rebuild`.
  719. - **Build markers inside test fixtures no longer label the project** — a
  720. `pom.xml` under `tests/fixtures/` or a `Package.swift` under `src/test/`
  721. belongs to the sample project a test indexes; `stats`, `map` and
  722. `detect-stacks` ignore markers under `test`, `tests`, `__tests__`,
  723. `fixtures`, `__fixtures__`, `test-fixtures` and `testdata` directories.
  724. - **`implementations` leaves out a namesake from another namespace** — a
  725. parent written `Legacy::ApplicationService` no longer counts as
  726. `ApplicationService` when the index defines both classes, and
  727. `< ::ApplicationService` is a direct child; on a large Rails app
  728. `implementations ApplicationService` lists 917 classes instead of 972.
  729. Package and namespace spellings of the same type (`extends com.acme.Base`,
  730. `: public acme::Base`, a namespace the index does not define) still match.
  731. - **A qualified declaration is no usage of itself** — `class
  732. Billing::Invoice` no longer records a reference to `Invoice` on its own line
  733. (a C# `namespace A.B` likewise); `Billing` stays a reference, and so does the
  734. parent of `class Admin::User < User`. Takes effect on the next `rebuild`.
  735. - **`stats` and `map` name the project** — `rebuild` records the stacks it
  736. finds (`Web (TypeScript/JavaScript) + Ruby`), `stats` prints them as
  737. `Project:` (JSON `project`, which the MCP `stats` tool already expected)
  738. and `map` in its header. Every `*.gemspec` directory is a Ruby module
  739. (`engines.billing`), so Rails engines show up in `module`, `map` and
  740. `--module`.
  741. - **`conventions` matches frameworks on whole name segments** — a rule no
  742. longer fires on any import that merely contains it: the Ruby gem
  743. `sequel-combine` is not Swift Combine, `preact` not React, and
  744. `../testing/setup` not Go's `testing`, while `CombineExt` is still Combine. Rails, Django, Flask, FastAPI,
  745. Express, Sidekiq, Celery, ActiveRecord and Sequel are recognised.
  746. - **`explore` picks tests from the mirrored directory** — among test files
  747. named after the source, one in the source's own directory comes first, then
  748. the ones whose directories end like the source's
  749. (`spec/services/billing/charge_spec.rb` for `app/services/billing/charge.rb`,
  750. `src/test/java/a/b/XTest.java` for `src/main/java/a/b/X.java`); when none
  751. shares a directory (a flat `tests/`, separate `*.Tests` projects) all are
  752. listed as before. Up to 50 candidates per name are considered instead of 5.
  753. - **`explore --rwr` takes callers from the symbol graph** — when `graph build`
  754. ran and the index has not changed since, neighbours are the definitions
  755. with a resolved edge to each seed instead of every reference sharing its
  756. name, which for a namespaced class found none. A seed the graph resolves no
  757. edge to (a call through a receiver of unknown type in Java, Swift, Go)
  758. keeps the name-matched callers.
  759. - **Performance table in the skill shows a large repository** — next to a
  760. small project; `search` on a 40k-file monorepo takes 250–550 ms, not 10.
  761. - **`explore` finds the class a question names** — candidates now also come
  762. from one bm25 ranking over all query words, from the words run together
  763. (`pdf to html service` is the `PdfToHtmlService` token the full-text index
  764. keeps whole) and from files whose path holds every word; before, each word
  765. sampled its first 40 matches in index order, so a common word such as
  766. `application` never reached `ApplicationService`. The type a file is named
  767. after and the symbol the query spells out rank first, a word in a symbol's
  768. own name counts above one in its namespace, and statements (`has_many :x`,
  769. `scope`, `include`), namespace-only modules and question words (`how`,
  770. `does`, `work`) rank low or are ignored. On a large Rails app 6 of 6 queries
  771. naming a class put it first instead of 1 of 6, for about 30 ms more per
  772. query on a 300k-symbol index.
  773. - **`explore` outlines types and modules** — a class, module or statement is
  774. shown as the outline of the definition around it (`:34-53 process
  775. [function]` rows with line ranges from the index, the chosen symbol marked
  776. `→`, at most 40 rows) instead of the first lines of its source; functions
  777. keep their source. JSON `files[]` carry `outline` and `outline_hidden` in
  778. place of `source` for those, and the MCP `search` fallback renders them.
  779. - **MCP `explore` answers in compact text** — the tool returned the raw CLI
  780. JSON, with source escaped into strings, although its description promised
  781. text by default; it now renders the report the `search` fallback prints under
  782. an `explore: <query>` line, less than half the size. `format: "json"` still
  783. returns the JSON.
  784. - **Definitions rank above imports** — inside every relevance tier of `search`
  785. (plain, `--fuzzy`, `--rank`) definitions now come before imports, and imports
  786. never enter the last-segment tier: `search InstallRequirement` in pip lists
  787. the class first instead of 12th behind eleven imports, and `search Result` in
  788. a Rust project no longer answers with a wall of `use anyhow::Result`.
  789. - **Schema columns named after the query rank first** — `.` now separates name
  790. segments like `::`, so `search email -t column` lists `users.email` and every
  791. other `*.email` column before `email_communicator_email_id`-style columns.
  792. - **Namespaced Ruby classes found by short or full name** — `symbol`, `class`,
  793. `refs`, `hierarchy` and `implementations` find `class Billing::Invoice` by
  794. `Invoice` or `Billing::Invoice` (Ruby stores the full name and no qualified
  795. name, so `hierarchy` and `class` used to answer "not found"); an exact short
  796. name still wins. `usages Billing::Invoice` lists references to `Invoice` on
  797. lines that spell the full name out.
  798. - **`proven` favours settled, living examples over abandoned ones** — the score
  799. is now mean(calm, mature, used) × substance × lineage: files under 10 lines
  800. and empty class bodies score half, and so does code built on a base class the
  801. project stopped extending; time since the last change is no longer scored. On
  802. 11 "which one to copy" queries the top five held 40 good examples of 55
  803. instead of 22.
  804. - **Test symbols after production code** — in the partial-match tiers of
  805. `search`, symbols in test files or named `test_*` / `TestX` follow the rest;
  806. exact names keep their place.
  807. - **`usages` lists production code first** — references in test files follow
  808. those in production files, each group by path and line (also in `refs`); JSON
  809. marks test references with `"test": true`.
  810. - **Skip references inside the Rails schema dump** — `t.string` / `t.integer`
  811. in `db/schema.rb` no longer count as uses of the project's `string` /
  812. `integer` methods (≈3.7k references and 2.6k ambiguous graph edges fewer on a
  813. large Rails app); tables and columns stay indexed.
  814. - **C/C++ prototypes are declarations** — a header prototype, `static` forward
  815. declaration, class method declaration or function-pointer field no longer
  816. counts as a use of the function.
  817. - **Ruby callbacks link to their methods** — `before_save :normalize`,
  818. `validate :check`, `validates :email`, `if:` / `unless:`,
  819. `rescue_from ... with:`, `alias_method`, `delegate` and `&:name` are
  820. references; the graph links a model to its callback methods and validated
  821. columns.
  822. - **Compact `outline` for schema dumps** — `db/schema.rb` columns fold into a
  823. count per table (164 KB → 17 KB on a 335-table schema); `--full` lists every
  824. column.
  825. - **`call-tree` shows same-named callers with their file** — two `it "works"`
  826. blocks or `export` methods of different files used to print as `(recursive)`
  827. without a path and still use up `--limit`. Every caller now prints with its
  828. file, a caller named like one already expanded is marked `(expanded above)`,
  829. and `(recursive)` marks only a definition already on its own path.
  830. - **`call-tree` attributes calls to real definitions** — an import or
  831. annotation line (`use`, `import`, `include Mod`, Rails callbacks) no longer
  832. owns a call, and a line declaring the function itself (Go `func (s *T) Name(`,
  833. a JavaScript method, `attr_reader :name`) is no longer its own caller. The
  834. same owner rule serves `explore --rwr` and the symbol graph.
  835. - **`callers` / `call-tree` stop reading symbols and paths as calls** —
  836. `authorize(record, :update?)` is no call of `update`, and `use super::name;`
  837. or `Billing::Name` without a call is no call of `name`; callbacks, `delegate`
  838. and `&:name` still count.
  839. - **The symbol graph resolves Rust paths** — files are modules, `crate::` /
  840. `super::` / `self::` and `use` declarations (grouped, aliased, globbed,
  841. `pub use`) are followed, and workspace crates are reached by their
  842. `Cargo.toml` name. On this repository calls through a module path went from
  843. 0 to 1160 of 1161 resolved; `graph dependents open_db` lists 38 dependents
  844. instead of none.
  845. - **`graph dependents` and `graph impact` take `--exclude-tests`** (MCP
  846. `graph_dependents`: `exclude_tests`) — test dependents are left out of the
  847. list and the counts, and `impact` does not follow them.
  848. - **Graph answers say what they merge and leave out** — the definitions a bare
  849. name matches are capped by `--limit` with a hint to narrow the query, and a
  850. column query explains that only reads inside the model are edges and points
  851. to `usages`.
  852. - **Faster graph queries** — freshness is checked against an index write
  853. generation and the highest row ids instead of counting and summing the
  854. tables: about 35 ms off every graph query and `search --rank` on a large
  855. monorepo.
  856. - **`hotspots --sort fixes` discounts thin history** — files are ordered by the
  857. lower bound of the 95% Wilson interval of their bugfix share, and files with
  858. fewer than four commits follow the rest, so 11 fixes in 17 commits rank above
  859. 2 in 2.
  860. - **Bracketed fix tags count as bugfixes** — only tracker keys (`[ABC-123]`,
  861. `ABC-123:`, `#42`, several in a row) are stripped before matching, so
  862. `[HOTFIX][ABC-123] …`, `[FIX]`, `[BUGFIX]` and `хотфикс` count as fixes; the
  863. store layout moved to `commits-v2`, so the first `--collect` recollects once.
  864. - **MCP descriptions no longer overpromise** — `usages` claimed it never
  865. matches comments or strings and `callers` that it attributes calls to the
  866. calling function; both now say what they do (`callers` points to
  867. `call_tree`), and the heaviest descriptions were trimmed: `tools/list`
  868. 27.3 → 24.4 KB.
  869. - **`search`, `callers` and `call-tree` skip files that cannot match** — the
  870. index now keeps each file's distinct words (`file_words`, about +7–10% index
  871. size), and the grep-based commands no longer open a file whose words lack
  872. the searched literal while it is unchanged since indexing; edited and new
  873. files are still searched. On a 40k-file Rails monorepo `search` went from
  874. 0.67 to 0.33 s, `callers merge` from 0.60 to 0.26 s, `call-tree --depth 3`
  875. from 1.13 to 0.66 s, with the same results. An index built by an older
  876. version is searched in full until its next `rebuild`.
  877. - **`callers` checks for definitions cheaply and in parallel** — the "is this
  878. line a definition?" test ran a capturing regex on one thread for every call
  879. line; a capture-free pre-check now runs on the search threads.
  880. - **`graph build` 2.5× faster** — references are resolved per file in parallel
  881. and import matches memoized, with an identical graph: 4.2 → 1.7 s.
  882. - **`hotspots --collect` reads history 5× faster** — `git log` windows run in
  883. parallel (up to 8), and a window of old bulk-import commits no longer
  884. overflows the 16 MB output cap and gets re-read at half size again and
  885. again: a full collection of a 25k-commit history took 50 s, now 10 s, with
  886. the same stored history.
  887. - **The MCP server answers tool calls concurrently** — several calls sent at
  888. once used to wait for each other; responses may now arrive out of order,
  889. matched by `id` as JSON-RPC allows.
  890. - **`rebuild` keeps the collected Git history** — the per-commit store, the
  891. per-file signals and the collection cursor are copied into the new index
  892. instead of being dropped, so `hotspots` reports right after a rebuild and the
  893. next `--collect` stays incremental: on a 25k-commit monorepo 0.2 s instead of
  894. a full rescan of a minute or more, for about 0.4 s added to the rebuild.
  895. History collected by an older version, from another working tree or scope,
  896. or that cannot be read back intact is left behind with a note, and the next
  897. `--collect` reads it again. `--sub-projects` / `--include` rebuilds lost it
  898. too and now keep it.
  899. - **snake_case calls are references in every language** — the generic
  900. reference extractor did not allow `_` in a called name, so `usages`, `refs`
  901. and the graph missed `update_profile(user)` and `self._compute()` in Python,
  902. Rust, Go, C/C++, PHP, Lua, TypeScript and every other language using it
  903. (`usages open_db` on a Rust codebase went from 0 to 50 hits). Reserved words
  904. (`sizeof (x)`, `#if defined(X)`, Go `func (r *T)`, Rust `pub(crate)`,
  905. Python `None`) are no longer recorded as references. In Ruby, a lowercase
  906. `name(` inside a comment, string or heredoc is no longer a reference.
  907. - **BSL and stylesheets use their own reference extractors again** — the
  908. trait default sent every language to the generic ASCII extractor, so BSL
  909. (1C:Enterprise / OneScript) files had no Cyrillic references at all and
  910. CSS, SCSS and Less recorded kebab-case fragments. BSL now records Cyrillic
  911. calls, modules before `.` and types after `Новый`, with the source line as
  912. context; stylesheets record none.
  913. - **One test-path rule** for `explore`, the symbol graph and `--exclude-tests`
  914. (`graph top`, `hotspots`, `search --rank`): adds `test_*.py`, `conftest.py`
  915. and `FooTest`/`FooTests`/`FooSpec` files in JVM/Swift/C#/PHP/C++, and stops
  916. treating Ruby namespaces under `app/`/`lib/` (e.g. `app/jobs/tests/`) and
  917. PascalCase JS component folders (`components/Test/`) as tests.
  918. - **First open of a project no longer slows down quadratically with the
  919. cache** — the cache-migration scan now lists the lease directory once
  920. instead of once per cached project (a first `rebuild` beside 5000 cached
  921. projects dropped from about 70 s to about 1.4 s).
  922. - **Cache GC removes lease lock files of caches that no longer exist** —
  923. `.leases` kept a `{key}.lock` and `{key}.publish.lock` for every cache ever
  924. opened, so it grew without bound. The cleanup after `rebuild` / `update` now
  925. deletes them whatever their age, and only under the cache-layout lock after
  926. locking both files itself, so a lock another process holds or is about to
  927. take is never split across two files. Every command that resolves the index
  928. gets faster on a cache that had accumulated them.
  929. - **Rails schema tables and columns** — `db/schema.rb` (indexed even when
  930. gitignored) yields `table` and `column` symbols (`users.email`;
  931. `search email -t column`, `outline db/schema.rb`). `graph build` matches
  932. tables to models by Active Record's rules — `self.table_name`, single-table
  933. inheritance, nested models, `table_name_prefix` / `isolate_namespace`, the
  934. pluralized class name — reports tables without a model and models without a
  935. table, and resolves column readers and attribute methods called inside a
  936. model (`email`, `self.email`, `email?`, `saved_change_to_email?`) as scoped
  937. edges to the column (`graph dependents users.email`).
  938. - **Ruby calls without parentheses are references** — `usages` and the graph
  939. now see `recv.name`, `name arg`, snake_case `name(...)` and bare `name` calls
  940. that are not local variables; core collection and string methods called
  941. without parentheses are skipped. RSpec `let` / `subject` helpers resolve
  942. within their spec file. On a Rails monorepo resolved graph edges grew from
  943. 66k to 186k; references nearly doubled for Ruby files.
  944. - **Compound Ruby constants are indexed** — `Billing::Import = Container.injector`
  945. becomes a constant named with its enclosing scopes like a class, and CamelCase
  946. assignments (`Types = Dry.Types()`) are indexed as constants too. In the graph a constant defined in
  947. an inner scope shadows an outer module of the same name, so
  948. `include Import[...]` inside `module Billing` no longer links every such
  949. class to an unrelated top-level `module Import`.
  950. - **Production code never resolves into test trees** — a spec helper that
  951. reopens a class to stub a method is no longer the target of production calls.
  952. - **One definition of third-party code** — only `node_modules` is left out of
  953. the graph; a project's `vendor/` directory and its own `.d.ts` files are
  954. graph nodes, while search ranking still demotes every `.d.ts`.
  955. - **`hotspots --collect` survives branch switches, rebases and resets** —
  956. history is kept per commit, so moving HEAD subtracts the commits it no longer
  957. reaches and adds new ones, reusing diffs already read; when a merge joins or
  958. leaves, files that differ between the two HEADs are recomputed too, so a file
  959. only a merge edited keeps a correct line count. A switch on a 25k-commit
  960. monorepo takes under a second instead of a ~1-minute rescan, and the numbers
  961. equal a fresh full collection at the same HEAD (line counts come from the
  962. working tree, so an uncommitted edit counts once the file is recomputed). The
  963. git tables are ~40% smaller. The first `--collect` after upgrading recollects
  964. once.
  965. - **Hotspot scores no longer collapse into ties** — `hotspots --sort score` and
  966. `search --rank hotspots|risky|proven` order by unrounded percentiles
  967. (`score_exact` in JSON).
  968. - **`--exclude-tests` for `hotspots` and ranked search** — `hotspots
  969. --exclude-tests` and `search --rank … --exclude-tests` (MCP: `exclude_tests`)
  970. hide spec/test files; percentiles still rank every file.
  971. - **`rewritten-often` only for files of 10+ lines** — relative churn is
  972. computed only for such files, so one-line bundles, fixtures and gutted files
  973. no longer read as "3000x file".
  974. - **Namespaced definitions lead `search`** — `search MergeService` had no exact
  975. hit for `class A::B::MergeService`, and bm25 put the shorter
  976. `describe "A::B::MergeService"` spec above the class. Names whose last `::`
  977. segment equals the query (case-sensitive) now rank right below exact names;
  978. statements such as `include A::B::MergeService` do not count. `search --rank`
  979. uses the same tier (`exact_last_segment`).
  980. - **Owning-symbol lookups stay within the file's root** — with an attached
  981. subtree holding a file under the same relative path, `call-tree` and
  982. `explore --rwr` could attribute a call to a method of the other root.
  983. - **Drop the redundant `idx_symbols_file` index** — it is the leftmost prefix
  984. of `idx_symbols_file_line_end`; new databases no longer create it and
  985. existing ones drop it on open. `restore` accepts backups with and without it;
  986. a backup made by this version cannot be restored by older releases.
  987. - **MCP `search` keeps its explore fallback** — a multi-word query without
  988. literal matches now renders `fallback: explore — <reason>` followed by
  989. source, ranked symbols, graph neighbours and tests instead of an empty
  990. `Files:` heading.
  991. - **`callers` and `call-tree` find bare Ruby predicate and bang calls** —
  992. `if next_page? && …` and `save!` without receiver or parentheses were
  993. missed; definitions, `#name?` in documentation and `!=`/`!~` are still
  994. skipped.
  995. - **Tests no longer write to the user's index cache** — `.cargo/config.toml`
  996. points `AST_INDEX_CACHE_DIR` at `target/ast-index-cache` for everything cargo
  997. starts; an explicitly set variable still wins.
  998. - **Name a wrapped default export after what it wraps** —
  999. `export default injectIntl(Header)`, `memo(Button)` or
  1000. `connect(mapState)(Page)` was indexed under the wrapper's name, so every file
  1001. applying `injectIntl` claimed a definition of it. Such an export is now
  1002. indexed as `default(Header)`, like `export default Header`. A wrapped inline
  1003. function or class is indexed like an anonymous default export, under the
  1004. module name. A call that builds a value from its configuration
  1005. (`createRouter({ … })`) keeps the callee's name.
  1006. - **Name an `index` default export after its package, not its build
  1007. directory** — `node_modules/pkg/dist/index.d.ts` was named `dist`; the name
  1008. now comes from the nearest directory above build and source directories.
  1009. - **`imports` lists every TypeScript/JavaScript import** — files were read
  1010. with a line pattern meant for Kotlin, so a multi-line `import {` printed as a
  1011. bare `{`, re-exports were not listed and a barrel `index.ts` reported
  1012. "No imports found". Imports and re-exports are now read from the syntax
  1013. tree, one declaration per line. Import symbols in the index stay limited to
  1014. project-local specifiers.
  1015. - **`search --type` no longer takes a minute on a large index** — with a kind
  1016. filter the bundled SQLite drove the query from the index on `kind`, scanning
  1017. every symbol of that kind and re-running the full-text match for each one:
  1018. `search Job --type class` took about a minute on a 320k-symbol index. The
  1019. full-text match now leads and the kind filters its hits, about a second, with
  1020. the same results.
  1021. - **`call-tree` prints the same tree on every run** — which callers made it
  1022. under `--limit` depended on the files the parallel scan happened to reach
  1023. first and on hash-map iteration order, so repeating a query could print a
  1024. different tree. Call lines are now taken in path order and attributed in
  1025. that order; files are still searched in parallel. Definition lines and files
  1026. outside `--in-file` no longer use up a function's match budget, so every
  1027. Sidekiq worker defining `perform` no longer crowds out the calls, and
  1028. `--in-file` no longer prints an empty tree while matching calls exist. The
  1029. repository is walked once per command rather than once per level: deep
  1030. trees got faster, while a single frequent name at `--depth 1` now pays for
  1031. the full walk up front.
  1032. - **`call-tree` stops expanding callers nothing can call** — a call inside an
  1033. RSpec block or a Rails DSL call is owned by a symbol named after that block
  1034. (`it "does nothing"`, `let(:fields)`, `attributes :id`). Such an owner is
  1035. still printed as a caller, but its name never occurs in code as a call, so
  1036. looking up its callers cost a scan of the whole repository and never found
  1037. any. Only callers whose name is an identifier — `Foo::Bar`, `save!`,
  1038. `valid?` and `name=` included — are expanded now.
  1039. - **`call-tree` scans once per level** — every function in the tree took a
  1040. scan of the whole repository to find its callers, so a level with nine
  1041. callers meant nine scans. Since calls resolve to the symbol that really
  1042. contains them, levels are wider and `call-tree` had slowed down several
  1043. times over. The functions a level needs are now looked up together in one
  1044. scan that still gives each of them its own match budget, so the printed tree
  1045. is the same and a level costs about one scan.
  1046. - **Calls behind a keyword are no longer taken for definitions** — `callers`
  1047. and `call-tree` skip definition lines by reading `Type name(` as a
  1048. declaration, and a keyword in the type position fooled it: `return foo(`,
  1049. `await foo(`, `new Foo(`, `if foo(`, `export default connect(` and the like
  1050. were dropped as if they declared `foo`. Such lines now count as calls; real
  1051. typed declarations are still skipped.
  1052. - **Index anonymous `export default` functions and classes** —
  1053. `export default () => {}`, `export default function () {}` and
  1054. `export default class {}` produced no symbol, so the function could not be
  1055. found and every call inside it had no owner in `call-tree` and
  1056. `explore --rwr`. Such a value is now indexed with its range under the name it
  1057. is imported by: the file name (`hooks/useMap.js` → `useMap`), or the
  1058. directory for an `index` file (`Button/index.jsx` → `Button`). A function is
  1059. classified like a declaration of that name, so a PascalCase component indexes
  1060. as a class; `outline` shows the same name. Named default exports are
  1061. unchanged.
  1062. - **Rank project code above dependencies in `search`** — within a ranking
  1063. tier, hits in `node_modules` or `.d.ts` files were ordered against project
  1064. hits by path alone, so `node_modules/…` came ahead of `spec/` or `system/`.
  1065. Project hits now lead within each tier. The tier still decides first, so a
  1066. library's exact `useState` stays above a project's partial `useStateModal`.
  1067. A project-owned `vendor/` directory still counts as project code; `explore`
  1068. shares the same definition.
  1069. - **Rank symbol searches by relevance** — FTS symbol queries used to come back
  1070. in whatever order the engine produced, or sorted by name length, so a search
  1071. for `ApplicationService` listed every shorter sibling and never the class
  1072. itself. Matches are now ordered by exact name first (case-sensitive, then
  1073. case-insensitive), then by `bm25()` weighted towards the symbol name over its
  1074. signature, then by name length and finally by path and line, so repeated runs
  1075. return the same order. The candidate pool `explore` builds keeps its previous
  1076. unranked order — ranking it narrowed the pool to same-named symbols and made
  1077. its own scoring worse.
  1078. - **Attribute a call site to the function that really contains it** —
  1079. `call-tree` and `explore --rwr` used to blame the nearest definition line
  1080. above a reference, so a module-level call landed on the last method of the
  1081. file and an `include` or a constant could be reported as the caller. Both
  1082. now ask the index which symbol's line range encloses the reference and take
  1083. the innermost one. Languages whose parsers report no range keep the previous
  1084. behaviour.
  1085. ### 3.55.0
  1086. - **Tuist module helpers are understood** — besides `targets: [...]`, target
  1087. declarations inside `modules: [...]` are read, source directories are found
  1088. among common layouts (`Sources/X`, `X/Sources`, `X/Api`, `Tests/X`,
  1089. `X/Tests`), and nested `implementation:` / `tests:` configurations declare
  1090. `XImpl` / `XTests` targets with their own dependencies. Workspaces that moved
  1091. to per-module folders no longer lose those modules from the graph.
  1092. - **`update` refreshes the module graph when build files change** — adding,
  1093. removing or editing `build.gradle(.kts)`, `Package.swift`, `Project.swift`,
  1094. `pom.xml`, `ya.make` and other build files now updates `deps`, `dependents`,
  1095. `module-route` and `unused-deps` without a `rebuild`. Unchanged build files
  1096. cost nothing extra.
  1097. - **`rebuild --type modules` keeps resources and usages** — it used to delete
  1098. and re-insert every module, which cascaded into Android resources, XML
  1099. usages, iOS assets and storyboard usages. Modules are now synced in place and
  1100. keep their ids.
  1101. - **`rebuild --verbose` lists manifests whose targets could not be read**, so
  1102. an incomplete module graph is visible instead of silent.
  1103. ### 3.54.0
  1104. - **Tuist projects get a module graph** — targets declared in `Project.swift`
  1105. (`.target(...)` or any project helper such as `.spmSwiftFolderTarget(name: .Foo, ...)`)
  1106. are indexed as modules with their `dependencies:` (`.target`, `.external`,
  1107. `.project`, `.product`), so `module`, `deps`, `dependents`, `module-route`
  1108. and `unused-deps` work on Tuist workspaces. Previously such a workspace had
  1109. no module dependencies at all.
  1110. - **SwiftPM modules point at their sources and have dependencies** — targets
  1111. resolve to `Sources/<Target>` / `Tests/<Target>` (or `path:` / `sources:`)
  1112. instead of `<package>/<Target>`, `let targets = [...]` declarations are read,
  1113. and target dependencies are indexed. Swift modules are named after the
  1114. target — the `import` name — and only fall back to a package-qualified name
  1115. when two manifests declare the same target. Manifests are parsed with
  1116. tree-sitter.
  1117. - **`unused-deps` understands Swift imports** — an `import Dep` in any file of
  1118. the module marks the dependency as used. Swift `import` declarations are now
  1119. indexed.
  1120. - **`api` lists Swift public API** — declarations marked `public` / `open`.
  1121. - **Swift local variables are no longer indexed as properties** — `let` / `var`
  1122. inside function bodies, closures and accessors are skipped, matching Kotlin.
  1123. - **Module-qualified supertypes resolve** — `class A : ru.pkg.Base()`,
  1124. `extension Foo: Module.Proto` are recorded with the simple parent name, so
  1125. `hierarchy` and `implementations` find them (previously the parent became
  1126. `ru` / `Module`).
  1127. - **`inject` finds constructor injection** — parameters of
  1128. `@Inject constructor(...)` and Java `@Inject` constructors, plus fields whose
  1129. annotation is on its own line.
  1130. - **`--limit` with a filter no longer under-reports** — `flows`, `suspend`,
  1131. `deprecated`, `suppress`, `deeplinks` applied the query after the limit was
  1132. spent (e.g. `flows --limit 5` could return 1). `suspend` reports the function
  1133. name instead of an extension receiver.
  1134. - **`provides` is an order of magnitude faster** — scans only files that
  1135. declare `@Provides` / `@Binds`.
  1136. - **`unused-symbols --module` accepts a module name** — `features.surge.impl`
  1137. or `:core:utils`, not just a path prefix.
  1138. - **`rebuild --type modules|deps|files` keeps the rest of the index** — a
  1139. partial rebuild used to publish an index without files and symbols.
  1140. ### 3.53.0
  1141. - **`search` no longer returns nothing for a multi-word query** — when a
  1142. query with two or more terms has no literal match, `search` now hands it to
  1143. the `explore` ranking engine and prints relevance-ranked symbols with their
  1144. source, honouring `--module` / `--in-file`. Text output is labelled
  1145. `No literal matches …`; JSON stays a single document and carries
  1146. `"fallback": "explore"` plus a `reason`. Single-term queries keep exact
  1147. literal semantics.
  1148. - **`callers` walks attached subtrees** — call sites inside a subtree added
  1149. with `subtree add` are found and shown as `[name] /abs/path`, matching
  1150. `usages` and `refs`. `--subtree NAME` restricts to that subtree, `--local`
  1151. to the primary root. Previously both flags were accepted and ignored.
  1152. - **`explore` accepts scope** — `--module` / `--in-file` narrow the candidate
  1153. set before ranking.
  1154. - **Agent guidance points intent queries at `explore`** — the skill and the
  1155. MCP `search` description now say to use `explore` for a question or a
  1156. description and `search` for a known identifier.
  1157. ### 3.52.0
  1158. - **Index C++ functions that return a pointer or a reference** — declarations
  1159. such as `Grid* GetGrid()`, `Player& FindPlayer()`, and
  1160. `const Grid* const GetEmptyPhaseShift()` are now indexed instead of being
  1161. skipped.
  1162. - **Install from crates.io** — the installation guide now documents
  1163. `cargo install ast-index --locked` as the released channel, with the Git
  1164. build kept as the way to install the unreleased default branch.
  1165. ### 3.51.0
  1166. - **Report truncated search results instead of hiding them** — `search`,
  1167. `symbol`, `class`, `implementations`, `refs`, `usages`, and `callers` now
  1168. print `showing N of M` with a `--limit` hint, and emit paginated JSON
  1169. schema v2 with `total`, `returned`, `truncated`, and `limit`.
  1170. - **Keep the index fresh without blocking edits** — `update --background
  1171. --debounce-ms <ms>` queues a coordinated, trailing-debounced generation and
  1172. returns immediately; index-reading commands wait for a queued generation
  1173. instead of answering from a stale index.
  1174. - **Scope watcher detection to the project** — the new `watch-status` command
  1175. reports whether this project has an active watcher, so a watcher in one
  1176. repository no longer suppresses updates in another. Session-start and
  1177. post-edit hooks and the generated Git hooks use it, and the session-start
  1178. hook now runs asynchronously with a visible status message.
  1179. - **Index Kotlin files containing `suspend { }` lambdas** — a suspend-lambda
  1180. syntax error no longer drops the enclosing interface, nested classes, and
  1181. later declarations from the index, and local `val` bindings are no longer
  1182. published as properties.
  1183. - **Count Kotlin references accurately** — references in a symbol's own
  1184. declaring file are kept when external references exist, and matches inside
  1185. string literals, comments, and KDoc are excluded while executable string
  1186. interpolation is still indexed.
  1187. - **Resolve kebab-case Gradle type-safe project accessors** — `deps`,
  1188. `dependents`, `unused-deps`, and `module-route` now link
  1189. `projects.core.designIcon` to `:core:design-icon`, and report ambiguity
  1190. instead of picking an arbitrary module.
  1191. - **Rebuild on Windows** — the staged index is synced through a
  1192. write-capable handle, fixing `failed to sync index file … (os error 5)`.
  1193. Concurrent runs are also recognized as ordinary lock contention instead of
  1194. failing with `failed to acquire index publication lock … (os error 33)`.
  1195. - **Detect nested project stacks** — `detect-stacks` performs a bounded
  1196. recursive marker scan and recognizes standard nested Kotlin Multiplatform
  1197. layouts such as `composeApp/src/commonMain`.
  1198. - **Document worktrees and cross-root workspaces** — independent git
  1199. worktrees keep independent indexes; intentional workspaces are attached
  1200. with `rebuild`, then `subtree add`, then `update`.
  1201. - **Compare ast-index and CodeGraph** — `docs/comparison.md` adds a dated,
  1202. source-backed feature comparison with pinned snapshots of both projects.
  1203. ### 3.50.0
  1204. - **Review branch changes quickly without building an index** — use `changed`
  1205. from the CLI or MCP to read cache-independent branch changes with
  1206. added, modified, deleted, and renamed files, rename metadata,
  1207. working-directory scope, a bounded VCS timeout, Git base auto-detection, and
  1208. stable JSON schema v1.
  1209. - **Migrate `changed` consumers to the file-level contract** — text output now
  1210. prints an A/M/D/R file summary instead of regex-derived declaration
  1211. pseudo-symbols. Scripts should request `--format json` and read
  1212. `changes[].status`, `changes[].path`, and `changes[].old_path` for renames.
  1213. Library callers can use the deprecated Rust compatibility wrappers while
  1214. migrating to the new API.
  1215. See [CHANGELOG.md](CHANGELOG.md) for earlier releases.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.