v1.0.4

[Unreleased]

v1.0.3

[1.0.3] - 2026-06-24

修复

• springgraph init、springgraph index 和 springgraph sync 在 Node 22+ 上不再重复打印 (node:…) ExperimentalWarning: SQLite is an experimental feature 警告。
• 进度输出在 Windows 终端、cmd、PowerShell 以及不支持 Unicode 的环境（包括 OEM 代码页）中不再显示为乱码或方块；如果默认输出仍有渲染问题，可设置 NO_COLOR=1 或 SPRINGGRAPH_ASCII=1 强制使用纯 ASCII 进度条。
• 大型 Spring Cloud 项目并行解析引用时，进度渲染不再阻塞主线程，减少了界面假死和行重复的概率。

v1.0.2

[1.0.2] - 2026-06-24

新功能

• Spring Cloud 项目现在拥有真正的 Maven 模块树：每个模块都会从 pom.xml 解析出来，文件会被映射到所属模块，服务模块也会与库模块、父 POM 模块区分开。springgraph_explore、架构快照和 Web UI 都会展示模块路径与服务边界，只需一次调用就能回答“这个类属于哪个微服务”。
• springgraph init 和 springgraph index 在大型项目上的速度大幅提升。在一个包含 10,000 个文件的合成 Spring Cloud 测试项目中，索引阶段本身比之前快约 4 倍；在未改动的代码树上重新运行几乎是瞬时的——内容未变化的文件会被跳过，不再重复解析或写入。跳过路径使用快速非加密哈希（xxhash，回退到 SHA-1）作为第一层校验，再用第二层 SHA-256 校验排除极罕见的误报。
• springgraph init 和 springgraph index 新增了 8 个可调参数，方便你根据机器配置调优：--threads（解析工作线程数，默认根据 CPU 数量推导）、--ram（总内存预算 MB，用于设置 SQLite 缓存和每个工作线程默认内存）、--batch-size（每个数据库事务包含的文件数）、--batch-flush-ms（按时间触发刷盘的阈值）、--size-limit（单个文件大小上限 MB，替代之前的 1 MB 硬限制）、--worker-ram（每个工作线程的 RSS 预算）、--use-git / --no-git（强制启用或禁用 git-native 文件枚举），以及 --progress-interval-ms（进度回调节流间隔）。每个参数都有对应的环境变量（例如 SPRINGGRAPH_THREADS、SPRINGGRAPH_NO_PARALLEL_INIT=1），便于在 CI 和容器环境使用。
• 为支持新的跳过路径，底层数据库 schema 已升级到 v7。现有索引在首次运行时会自动迁移。同时提供了两个环境变量用于回退到旧行为：SPRINGGRAPH_NO_PARALLEL_INIT=1 回退到单线程解析，SPRINGGRAPH_NO_BATCH_WRITES=1 回退到逐文件数据库事务。两者默认均为关闭（新路径是默认）。

维护

• .opencode/ 目录（OpenSpec 本地开发工具）已从仓库中彻底移除：加入 .gitignore 并通过 git filter-branch 从全部历史提交中清除。新克隆的仓库不再包含此目录。

v1.0.1

[1.0.1] - 2026-06-13

New Features

• New codegraph daemon command (alias daemons) — an interactive manager for the background daemons. It shows what's running (your current project's daemon first, pre-selected), and you arrow-key to one and press enter to stop it, or pick "Stop all". Previously the only way to shut a daemon down was to hunt for its pid and kill it by hand. (#845)
• Checking your installed version is now easy to reach however you guess at it: codegraph version, codegraph -v, and codegraph -version all print it, alongside the existing codegraph --version. (#864)
• The CodeGraph MCP server now self-heals if its main thread ever locks up. A lightweight watchdog notices when the process has stopped responding and stops it so a fresh one starts on your next request — it can no longer sit pinned at 100% CPU with no way to recover. Tune the detection window with CODEGRAPH_WATCHDOG_TIMEOUT_MS, or turn it off entirely with CODEGRAPH_NO_WATCHDOG=1. (#850)

Fixes

• Git worktrees nested inside your project — like the .claude/worktrees/ that Claude Code creates — are no longer indexed as duplicate copies of your whole codebase. CodeGraph deliberately indexes genuine embedded repos (a real second project checked out inside yours), but a worktree is just another working view of a repo it already indexed, so each one was multiplying every symbol — one report went from ~1,850 files to over 24,000, with search and explore flooded by stale duplicates. CodeGraph now recognizes worktrees and skips them, while still indexing real embedded repos and submodules. Thanks @tphakala. (#848)

• Running codegraph serve --mcp by hand no longer just hangs in silence. That command is the MCP server your AI agent starts for itself — not a step you run directly — and in a terminal it used to sit there waiting for input that never comes, looking broken. It now recognizes when a person runs it and explains what to do instead (codegraph status, codegraph daemon), and it's been dropped from the command listing so it stops looking like something you need to launch.

• Cross-file static method calls like ClassName.staticMethod() now resolve correctly. CodeGraph was linking the call to the class instead of the method (and recording it as a construction), so callers and impact for a static method came back empty — a real blind spot in TypeScript and JavaScript codebases that lean on static utility classes (Python and other languages with the same call shape benefit too). The call now links to the method itself. Thanks @contextFlow-lab. (#825)

• codegraph affected now accepts ./-prefixed and absolute file paths, not just bare project-relative ones. Passing ./src/x.ts or an absolute path — common when the file list comes from another tool — used to silently match nothing and report no affected tests. Thanks @contextFlow-lab. (#825)

• The CodeGraph MCP server no longer risks getting stuck at 100% CPU after an unexpected internal error. Previously such an error was logged but the process was left running in a broken state, where it could spin a CPU core indefinitely and had to be killed by hand. The server now logs the error and exits cleanly, so a fresh one starts on the next request. Thanks @songhlc. (#850)

• CodeGraph no longer indexes your entire home directory by accident. Running the installer — or codegraph init / codegraph index — from your home folder or a filesystem root would index everything underneath it (caches, Library, every other project), producing a multi-gigabyte index and constant file-watching churn. CodeGraph now refuses these roots and points you at a specific project instead; pass --force if you genuinely mean to. (Combined with the macOS file-descriptor fix already in 1.0.0, this closes the report of a runaway watcher exhausting the system file limit.) Thanks @ligson. (#845)

• Java and Kotlin super.method() calls inside an override now resolve to the inherited superclass implementation instead of looping back to the subclass override. This fixes missing or self-referential callee links for override bodies that delegate to their parent. Existing Java and Kotlin indexes should be re-indexed (codegraph index -f) to benefit.

• Java and Kotlin class inheritance via extends now participates in polymorphic dispatch the same way implements already did: codegraph_callers and codegraph_callees on a base-class method aggregate call sites from its subclasses' overrides, and vice versa. This closes gaps in impact and trace for inherited method overrides. Existing Java and Kotlin indexes should be re-indexed (codegraph index -f) to benefit.

• Decorators extracted by tree-sitter (e.g. @Service, @Component, @Route, @RestController) are now stored in the node's decorators column in the index, making them visible to search, the /api/decorators endpoint, and the /api/search?decorator= filter. Previously only Kotlin's @ExperimentalStdlibApi-style annotations populated this column; other languages silently dropped them.

• After sync adds new class or interface nodes, the architecture facet cache now re-detects the project profile so those nodes are immediately classified by role, layer, and module — instead of staying generic until the next full re-index.

• codegraph index now rebuilds the full graph from scratch, so it produces the same result as a fresh codegraph init instead of reporting "0 nodes, 0 edges" and looking like it wiped your index. Previously, re-running index on an unchanged project skipped every file (their contents hadn't changed) and showed an empty-looking summary; it now clears and re-indexes for an honest, complete rebuild every time. Use codegraph sync for fast incremental updates between full rebuilds. Thanks @Arc-univer. (#874)

• The file watcher that auto-syncs the graph now fails cleanly when live watching can no longer be trusted, instead of looking healthy while the index quietly goes stale. If the operating system runs out of file-watch resources, or another process holds the write lock far longer than a normal save, CodeGraph now disables auto-sync once — with a single clear message telling you to run codegraph sync (or rely on the git sync hooks) to refresh — rather than retrying forever or repeating the same error on a loop. And while auto-sync is disabled, CodeGraph's tool responses (and codegraph status) now say so plainly, so your AI agent knows to read files directly instead of trusting a frozen index. This mostly matters for long-running MCP/daemon sessions, which could otherwise keep serving stale results while appearing to work. Thanks @thismilktea. (#876)

• On Linux, hitting the kernel's inotify watch limit on a large project no longer silently leaves half the tree unwatched. CodeGraph now tells you once — naming the exact setting to raise (fs.inotify.max_user_watches, e.g. sudo sysctl fs.inotify.max_user_watches=1048576) — and keeps live-watching the directories it could register while codegraph sync (or the git sync hooks) covers the rest. (#876)

Housekeeping

• Local development artifacts are now ignored by git: .claude/, .cursor/, .omo/, 资料/, openspec/, .playwright-mcp/, and the old .codegraph_bak/ backup. These remain on disk for the developer but no longer ship in the repository.

New Features

• Java and Kotlin projects now get Spring-aware relationship synthesis: @Autowired/@Resource field injection, explicit constructor injection, and Lombok @RequiredArgsConstructor are modeled as references edges from the consuming bean to the injected bean. Interface method dispatch is also bridged with overrides edges to concrete implementations, and overloaded methods are disambiguated by arity. MyBatis XML mappers are linked to their Java Mapper methods, SQL table/column hints are extracted, and XML column references are connected to entity fields by naming convention. application.yml / application.properties keys are indexed as constant nodes and wired to @Value and @ConfigurationProperties bindings. All of these edges are additive, carry provenance:'heuristic', and surface in codegraph_explore, codegraph_node, codegraph_callers, and codegraph_impact.

• Impact and blast-radius analysis for TypeScript, JavaScript, Go, Python, Rust, Ruby, C, Java, C#, PHP, Scala, Kotlin, Swift, Dart, and Pascal/Delphi now understands the readers of a constant. When you change a file-scope, package-level, module-level, or class-level constant — a config object, a lookup table, a shared constant — the other symbols in that file that read it now show up as affected, where before they were invisible (impact only followed calls, imports, and inheritance, so a constant's consumers looked like "nothing depends on this"). This makes codegraph impact, and the impact trail in codegraph_explore/codegraph_node, catch the "change this table, break its readers" class of change. It's on by default and adds no nodes to your graph; bundled/minified files and ambiguously-shadowed names are skipped to keep results precise. Set CODEGRAPH_VALUE_REFS=0 to turn it off.

• C file-scope constants and globals — static const scalars, pointer/array lookup tables, and shared mutable globals — are now recognized as symbols in their own right. They previously weren't extracted at all, so they never appeared in search or carried any dependents; now they show up in codegraph search and participate in impact analysis (see above), so changing a C lookup table surfaces the same-file functions that read it.

• Java static final constants, C# const / static readonly constants, Scala object vals, and Kotlin top-level / object / companion object vals are now classified as constants rather than generic fields, so they participate in the constant-reader impact analysis above — change a public static final table, a const string, a Scala `object Config { val Timeout...