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 = … }, or a Kotlin companion object { const val … } and the methods that read it now show up as affected. (Per-object Java final / C# readonly / Scala & Kotlin class instance properties are unchanged.) Kotlin constants were previously not indexed as their own symbols at all, so they now also appear in codegraph search.

• Swift top-level lets and static let constants (including those namespaced in an enum/struct, the common Swift pattern) are now indexed as constants and participate in the constant-reader impact analysis above — change a static let defaultRetryLimit or an enum Constants { static let … } and the same-file code that reads it shows up as affected. Computed properties and per-instance lets are not treated as constants.

• Dart top-level const/final and class static const/static final constants are now indexed as constants and participate in the constant-reader impact analysis above. Instance fields, vars, and locals are not treated as constants. (Generated Dart code with the standard .g.dart/.freezed.dart/.pb.dart suffixes is already skipped.)

New Features (springkg)

• SpringKg: Added SpringCloud semantic knowledge graph layer with SQLite schema in springkg.db for storing Spring symbols, endpoints, Feign clients, and configuration properties.
• SpringKg: Added 4 MCP tools (spring_find_entry, spring_find_feign, spring_assets_overview, spring_trace_flow) for querying Spring Boot assets and tracing request flows across controller, service, and data-access layers.
• SpringKg: spring_trace_flow accepts url and depth parameters to trace HTTP endpoints through controller, service, mapper, and SQL layers.
• SpringKg: spring_assets_overview returns an inventory of indexed controllers, services, middlewares, and sensitive configuration properties.
• SpringKg: Added semantic resolvers for Spring annotations (@RestController, @Service, @Mapper), REST endpoints, and OpenFeign client resolution.