@colbymchenry/codegraph 0.9.9 → 1.0.0

package/dist/extraction/index.d.ts

@@ -53,6 +53,40 @@ export declare function hashContent(content: string): string;
  * it project code; the explicit `.gitignore` negation is the only opt-in).
  */
 export declare function buildDefaultIgnore(rootDir: string): Ignore;
+/**
+ * Workspace-scope ignore matcher. Ordinary paths get the root's matcher
+ * (built-in defaults + root `.gitignore`); paths inside an EMBEDDED repo get
+ * that repo's own matcher (defaults + its root `.gitignore`) — the parent's
+ * `.gitignore` hides a child repo from git, not from the index (#514). A
+ * directory path (trailing slash) that is an ANCESTOR of an embedded root is
+ * never ignored, so directory-pruning callers (the Linux per-directory
+ * watcher) still descend to reach the embedded repos.
+ *
+ * Single source of truth for indexer and watcher scope — they must not diverge.
+ */
+export declare class ScopeIgnore {
+    private rootMatcher;
+    private embedded;
+    private defaults;
+    constructor(rootMatcher: Ignore, embedded: Array<{
+        root: string;
+        matcher: Ignore;
+    }>);
+    ignores(rel: string): boolean;
+}
+/**
+ * Build the workspace-scope matcher. When the caller already knows the
+ * embedded roots (the scanner discovers them during collection), pass them to
+ * skip rediscovery; otherwise they're discovered here (the watcher path).
+ */
+export declare function buildScopeIgnore(rootDir: string, embeddedRoots?: Iterable<string>): ScopeIgnore;
+/**
+ * Standalone discovery of every embedded repo root under `rootDir` (relative,
+ * trailing-slashed) — both the untracked kind (#193) and the gitignored kind
+ * (#514), recursively (an embedded repo can embed further repos). Returns []
+ * for non-git roots: the filesystem walk handles nested repos there already.
+ */
+export declare function discoverEmbeddedRepoRoots(rootDir: string): string[];
 /**
  * Recursively scan a directory for source files.
  *

package/dist/extraction/languages/c-cpp.d.ts

@@ -1,4 +1,12 @@
 import type { LanguageExtractor } from '../tree-sitter-types';
+/**
+ * Normalize a C++ return type to the bare class name a method could be called
+ * on. Unwraps smart-pointer / optional wrappers to their element type
+ * (`std::unique_ptr<Widget>` → `Widget`) so a factory's `->method()` resolves on
+ * the pointee. Strips cv-qualifiers, `&`/`*`, namespace qualifiers, and other
+ * template args. Returns undefined for primitives / void / `auto` / empty.
+ */
+export declare function normalizeCppReturnType(raw: string): string | undefined;
 export declare const cExtractor: LanguageExtractor;
 export declare const cppExtractor: LanguageExtractor;
 //# sourceMappingURL=c-cpp.d.ts.map

package/dist/extraction/languages/csharp.d.ts

@@ -1,3 +1,25 @@
 import type { LanguageExtractor } from '../tree-sitter-types';
+/**
+ * Blank C# conditional-compilation directive lines (`#if` / `#elif` / `#else` /
+ * `#endif`) before parsing. The vendored tree-sitter-c-sharp grammar mis-parses
+ * a `#if` that appears *inside an enum member list* — the canonical
+ * multi-targeting shape:
+ *
+ *   enum ReadType {
+ *   #if HAVE_DATE_TIME_OFFSET
+ *       ReadAsDateTimeOffset,
+ *   #endif
+ *       ReadAsDouble,
+ *   }
+ *
+ * It emits an ERROR that, for a nested enum, detaches the *enclosing class's*
+ * member list, so most of the class's methods drop out of the index. Removing
+ * the directive lines (keeping the guarded code) sidesteps it. Both branches of
+ * an `#if/#else` are kept — the same behaviour the previous grammar produced,
+ * and the right default for a code graph (index every symbol regardless of
+ * build flags). Replacement preserves byte offsets (directive text → spaces,
+ * newlines kept) so every symbol's line/column stays exact. (#237)
+ */
+export declare function blankCsharpPreprocessorDirectives(source: string): string;
 export declare const csharpExtractor: LanguageExtractor;
 //# sourceMappingURL=csharp.d.ts.map

package/dist/extraction/languages/r.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const rExtractor: LanguageExtractor;
+//# sourceMappingURL=r.d.ts.map

package/dist/extraction/languages/typescript.d.ts

@@ -1,3 +1,16 @@
 import type { LanguageExtractor } from '../tree-sitter-types';
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+/**
+ * A TS/JS class field (`public_field_definition` / `field_definition`) is a
+ * METHOD only when its value is callable — an arrow function, a function
+ * expression, or a HOF call wrapping one (`onScroll = throttle(() => {…})`),
+ * exactly mirroring what `resolveBody` below knows how to walk. Everything
+ * else (`public fonts: Fonts;`, `count = 0`, `static defaults = {…}`) is a
+ * PROPERTY. Previously every field extracted as method-kind (#808), which
+ * misrepresented class shape and defeated kind-based filtering — the reason
+ * #756's function-ref resolution had to restrict TS/JS bare identifiers to
+ * function targets.
+ */
+export declare function classifyTsClassMember(node: SyntaxNode): 'method' | 'property';
 export declare const typescriptExtractor: LanguageExtractor;
 //# sourceMappingURL=typescript.d.ts.map

package/dist/extraction/liquid-extractor.d.ts

@@ -24,6 +24,13 @@ export declare class LiquidExtractor {
      * Create a file node for the Liquid template
      */
     private createFileNode;
+    /**
+     * Shopify OS 2.0 JSON template / section group. Both have a `sections` object
+     * mapping an id → `{ "type": "<section-name>", ... }`; the `type` names a
+     * `sections/<type>.liquid` file. Emit a `references` edge to each, so a section
+     * used only from a JSON template (the OS 2.0 norm) is no longer orphaned.
+     */
+    private extractShopifyJsonSections;
     /**
      * Extract {% render 'snippet' %} and {% include 'snippet' %} references
      */

package/dist/extraction/razor-extractor.d.ts

@@ -0,0 +1,42 @@
+import { ExtractionResult } from '../types';
+export declare class RazorExtractor {
+    private filePath;
+    private source;
+    private nodes;
+    private edges;
+    private unresolvedReferences;
+    private errors;
+    constructor(filePath: string, source: string);
+    extract(): ExtractionResult;
+    private createComponentNode;
+    /** Last `.`-segment (`App.ViewModels.RegisterModel` → `RegisterModel`). */
+    private lastSegment;
+    /**
+     * Split a type expression into the capitalized type names it contains — base
+     * type plus any generic arguments (`Bar<Foo, Baz>` → `Bar`, `Foo`, `Baz`),
+     * each reduced to its last namespace segment. Lowercase/keyword tokens drop out.
+     */
+    private typeNames;
+    private pushRef;
+    private extractDirectives;
+    private extractComponentTags;
+    /**
+     * Find the matching `}` for the `{` at `openIdx`, skipping string literals and
+     * comments so a brace inside `"{"` / `// }` doesn't throw off the count.
+     * Returns the index of the closing brace, or -1 if unbalanced.
+     */
+    private matchBrace;
+    /** `@code { … }` / `@functions { … }` (Blazor) and `@{ … }` (Razor) C# blocks. */
+    private extractCodeBlocks;
+    /**
+     * Delegate each `@code`/`@functions`/`@{` block's C# to the tree-sitter C#
+     * extractor and attribute the block's external references (service/DTO calls,
+     * `new X()`, type uses) to the component. The block is wrapped in a synthetic
+     * class so tree-sitter parses the component's fields/methods in a class context
+     * (a Blazor `@code` body compiles into the component's partial class). We keep
+     * only the dependency references — coverage just needs the edges to external
+     * types, not per-member nodes. Degrades gracefully if the C# grammar isn't loaded.
+     */
+    private processCodeBlocks;
+}
+//# sourceMappingURL=razor-extractor.d.ts.map

package/dist/extraction/tree-sitter-types.d.ts

@@ -69,6 +69,15 @@ export interface ExtractorContext {
  * language-specific details like signatures, visibility, and imports.
  */
 export interface LanguageExtractor {
+    /**
+     * Optional source transform applied immediately before the grammar parses the
+     * file. Used to work around grammar gaps that would otherwise corrupt the
+     * parse tree (e.g. C# blanks conditional-compilation directive lines the
+     * grammar mis-parses inside enum bodies). MUST preserve byte offsets (replace
+     * removed text with spaces, keep newlines) so node positions and getNodeText
+     * stay correct; the returned string is used for both parsing and extraction.
+     */
+    preParse?: (source: string) => string;
     /** Node types that represent functions */
     functionTypes: string[];
     /** Node types that represent classes */
@@ -119,6 +128,14 @@ export interface LanguageExtractor {
     isStatic?: (node: SyntaxNode) => boolean;
     /** Check if variable declaration is a constant (const vs let/var) */
     isConst?: (node: SyntaxNode) => boolean;
+    /**
+     * Extract extra symbol-level modifier keywords to persist on the node's
+     * `decorators` list (e.g. Kotlin `expect`/`actual` multiplatform markers).
+     * Called generically for every created node; return undefined/[] when none.
+     * Used by the resolver to link `expect` declarations to their `actual`
+     * implementations across source sets.
+     */
+    extractModifiers?: (node: SyntaxNode) => string[] | undefined;
     /** Additional node types to treat as class declarations (e.g. Dart: 'mixin_declaration') */
     extraClassNodeTypes?: string[];
     /** Whether methods can be top-level without enclosing class (Go: true) */
@@ -135,6 +152,14 @@ export interface LanguageExtractor {
      * for multiple concepts (e.g. Swift uses class_declaration for classes, structs, and enums).
      */
     classifyClassNode?: (node: SyntaxNode) => 'class' | 'struct' | 'enum' | 'interface' | 'trait';
+    /**
+     * Classify a methodTypes node when the grammar reuses one node type for
+     * both callable and data members (#808): TS/JS class FIELDS
+     * (`public_field_definition` / `field_definition`) are methods only when
+     * their value is callable (`onClick = () => {}`); a plain field
+     * (`public fonts: Fonts;`, `count = 0`) is a property. Default: 'method'.
+     */
+    classifyMethodNode?: (node: SyntaxNode) => 'method' | 'property';
     /**
      * Resolve the body node for a function/method/class when it's not a child field.
      * (e.g. Dart puts function_body as a sibling, not a child.)
@@ -156,6 +181,14 @@ export interface LanguageExtractor {
      * When present, the receiver type is included in the qualified name for better searchability.
      */
     getReceiverType?: (node: SyntaxNode, source: string) => string | undefined;
+    /**
+     * Extract a function/method's normalized return type name (bare class name,
+     * smart-pointer pointee unwrapped), stored on the node as `returnType`. Used
+     * by C/C++ so resolution can infer a chained receiver's type from what the
+     * inner call returns (`Foo::instance().bar()` → resolve `bar` on `Foo`,
+     * issue #645). Return undefined for primitives / void / constructors.
+     */
+    getReturnType?: (node: SyntaxNode, source: string) => string | undefined;
     /**
      * Resolve the actual node kind for a type alias declaration.
      * Used by Go where `type_spec` is the named declaration wrapper for structs/interfaces:

package/dist/extraction/tree-sitter.d.ts

@@ -20,11 +20,45 @@ export declare class TreeSitterExtractor {
     private extractor;
     private nodeStack;
     private methodIndex;
+    private fnRefSpec;
+    private fnRefCandidates;
     constructor(filePath: string, source: string, language?: Language);
     /**
      * Parse and extract from the source code
      */
     extract(): ExtractionResult;
+    /**
+     * Function-as-value capture (#756): if this node is one of the language's
+     * value-position containers (call arguments, assignment RHS, struct/object
+     * initializer, array/table literal), collect candidate function names from
+     * it. Candidates are gated & flushed at end-of-file (flushFnRefCandidates).
+     */
+    private maybeCaptureFnRefs;
+    /**
+     * Candidates-only scan of a subtree the main walkers won't traverse
+     * (top-level variable initializers). No extraction side effects. Halts at
+     * nested function definitions: their bodies are walked — and their
+     * candidates attributed — by extractFunction's own body walk.
+     */
+    private scanFnRefSubtree;
+    /**
+     * Gate captured function-as-value candidates and push survivors as
+     * `function_ref` unresolved references.
+     *
+     * The gate bounds volume and protects precision: a candidate survives only
+     * if its name matches a function/method DEFINED IN THIS FILE or a name this
+     * file imports/references. Everything else (locals, params, fields passed
+     * as arguments) is dropped before it ever reaches the database. Resolution
+     * then matches survivors against function/method nodes only
+     * (matchFunctionRef) and emits `references` edges — which callers/impact
+     * already traverse.
+     *
+     * Known v1 limit, deliberate: a C/C++ callback registered in a DIFFERENT
+     * translation unit than its definition (extern, no symbol imports to match)
+     * is not captured. Same-file registration — the dominant C pattern (static
+     * callback + same-file ops struct) — is.
+     */
+    private flushFnRefCandidates;
     /**
      * Visit a node and extract information
      */
@@ -137,6 +171,14 @@ export declare class TreeSitterExtractor {
      * Returns true if children should be skipped (struct/interface handled body visiting).
      */
     private extractTypeAlias;
+    /**
+     * Extract the method specs of a Go `interface_type` body as `method` nodes
+     * contained by the interface (e.g. `Marshal`, `Unmarshal` of a `Core`
+     * interface). tree-sitter-go names these `method_elem` (newer) or
+     * `method_spec` (older). Embedded interfaces (`Reader` inside `ReadWriter`)
+     * are `type_identifier`s, not methods, and are left to inheritance extraction.
+     */
+    private extractGoInterfaceMethods;
     /**
      * Surface the members of a TypeScript `type X = { ... }` (or intersection
      * thereof) as `property` / `method` nodes under the type-alias node. Only
@@ -145,6 +187,34 @@ export declare class TreeSitterExtractor {
      * don't produce phantom members.
      */
     private extractTsTypeAliasMembers;
+    /**
+     * Surface the string-literal "names" of a TypeScript service/contract
+     * registry written as a tuple of generic instantiations:
+     *
+     *   type MyServiceList = [
+     *     Service<'query_apply_record', Req, Resp>,
+     *     Service<'apply_confirm', Req, Resp>,
+     *   ];
+     *
+     * Each `Service<'name', …>` tags an entry with a string-literal name that a
+     * dynamic factory (`createService<MyServiceList>()`) turns into a callable
+     * property (`api.query_apply_record(…)`). Static extraction otherwise never
+     * sees that name — it's a type argument, not a declaration — so
+     * `codegraph query query_apply_record` returned nothing (issue #634). We emit
+     * each name as a `method` node under the type alias (qualifiedName
+     * `MyServiceList::query_apply_record`) so it's searchable and resolvable as a
+     * symbol. (A call through the proxy, `api.query_apply_record(…)`, still
+     * resolves to the imported `api` binding — the receiver's type isn't known —
+     * so this fixes discoverability, not the per-method call edge.)
+     *
+     * Scope is deliberately narrow to avoid noise: only a string literal that is
+     * a DIRECT type argument of a `generic_type` that is itself a DIRECT element
+     * of a `tuple_type`. This excludes utility types (`Pick`/`Omit`/`Record` are
+     * never written as tuples) and string args nested deeper
+     * (`Service<'a', Pick<U, 'id'>>` yields only `a`, never `id`). Names must be
+     * valid identifiers, which also rules out route paths / arbitrary strings.
+     */
+    private extractTsTupleContractNames;
     /**
      * `foo: () => T` → property_signature whose type_annotation contains a
      * `function_type`. Treat that as a method-shaped contract member, since
@@ -158,6 +228,83 @@ export declare class TreeSitterExtractor {
      * Also creates unresolved references for resolution purposes.
      */
     private extractImport;
+    /**
+     * Emit one `imports` reference per named/default import binding (TS/JS family),
+     * attributed to the file node — so the resolver links each imported symbol to
+     * the file that DEFINES it.
+     *
+     * Importing a symbol IS a dependency, but extraction only emits references for
+     * calls, instantiations, type annotations, and inheritance. A symbol that's
+     * imported and then only re-exported (`export { X } from './x'`), placed in a
+     * registry array (`[expressResolver, …]`), passed as an argument, or used in
+     * JSX produced NO cross-file edge at all — so the providing file showed a
+     * false "0 dependents" and was invisible to blast-radius / `affected`. The
+     * resolver maps the local name (alias-aware) to the provider's definition and
+     * creates a cross-file `imports` edge; `getFileDependents` picks it up, while
+     * `getImpactRadius` keeps it as a bounded leaf (the importing file node).
+     *
+     * Namespace imports (`import * as NS`) bind a whole module: `NS.member` calls
+     * resolve on their own, but a namespace used ONLY via a value-member read
+     * (`NS.SOME_CONST`) would leave no edge — so we also emit the namespace local
+     * name, which the resolver links to the module FILE as a dependency backstop.
+     */
+    private emitImportBindingRefs;
+    /**
+     * Emit one `imports` reference per re-exported binding of a
+     * `export { A, B as C } from './y'` statement, attributed to the file node —
+     * so a barrel that re-exports from another module records a dependency on it.
+     *
+     * Links the SOURCE-side name (`A`, the `name` field — not the local alias
+     * `C`), since that is what the source module defines. `export * from './y'`
+     * has no named bindings to attribute and `export { default as X }` can't be
+     * name-matched, so both are skipped.
+     */
+    private emitReExportRefs;
+    /**
+     * Emit one `imports` reference per binding of a Rust `use` declaration —
+     * `use crate::m::Item`, `use crate::m::{A, B as C}`, `pub use self::sub::Item`.
+     * Emits the FULL path (e.g. `self::sub::Item`, not just `Item`) so the resolver
+     * can resolve the module prefix to a file and find the leaf symbol there —
+     * disambiguating common-name re-exports (`pub use self::read::read`, where the
+     * leaf `read` collides with many same-named symbols). Falls back to name-match
+     * on the leaf when the path can't be resolved. `use ...::*` has no leaf binding.
+     */
+    private emitRustUseBindingRefs;
+    /**
+     * Emit an `imports` reference for a single PHP `use Foo\Bar\Baz;` (grouped
+     * imports `use Foo\{A, B}` are handled where their per-item nodes are created).
+     * The reference targets the namespace-qualified `Foo\Bar::Baz` form classes are
+     * stored under (see the PHP `namespace` capture), so it resolves to the RIGHT
+     * definition — Laravel has many same-named contracts (`Factory`, `Dispatcher`,
+     * `Guard`) across namespaces that a bare-name match can't disambiguate.
+     */
+    private emitPhpUseRefs;
+    /**
+     * Ruby `require`/`require_relative` → an `imports` ref to the required FILE.
+     * `require "sidekiq/fetch"` is load-path-relative (matched by file-path suffix
+     * via {@link matchByFilePath}); `require_relative "../foo"` is resolved against
+     * this file's directory. Bare gem/stdlib requires (`require "json"`, no slash)
+     * are skipped — they're external. The path form (a `/` + `.rb`) makes the ref
+     * resolve to the file node, so a file pulled in only by `require` — not by a
+     * resolved constant/call — still records a cross-file dependency.
+     */
+    private emitRubyRequireRefs;
+    /** Convert a PHP FQN `Foo\Bar\Baz` to the stored `Foo\Bar::Baz` and emit an `imports` ref. */
+    private pushPhpUseRef;
+    /**
+     * Emit one `imports` reference per name imported in a Python
+     * `from module import A, B as C` statement, attributed to the file node — so
+     * the resolver links each imported name to the module that DEFINES it.
+     *
+     * Same recall gap as TS: extraction only emitted references for calls,
+     * instantiations, and inheritance, so a name imported and then used in a
+     * non-call position (a list/dict literal, a default argument, a decorator
+     * target, or simply re-exported through an `__init__.py` barrel) produced no
+     * cross-file edge — the providing module showed a false "0 dependents". Links
+     * the LOCAL name (alias when present, since that's what the resolver's import
+     * mapping keys on); `from module import *` has no names to attribute.
+     */
+    private emitPyFromImportRefs;
     /**
      * Extract a function call
      */
@@ -172,6 +319,18 @@ export declare class TreeSitterExtractor {
      * arguments (`new Foo(bar())`) get their own `calls` references.
      */
     private extractInstantiation;
+    /**
+     * Static-member / value-read pass. A type/enum/class used only via a member
+     * VALUE — `Enum.value`, `Type.CONST`, `Colors.red`, `Foo::BAR` — recorded no
+     * edge, because the body walker only handled CALLS (`Type.method()`). So a
+     * type referenced only by an enum value or a static field looked like nothing
+     * depended on it (the residual frontier across Dart/Java/C#/Swift/Kotlin/PHP).
+     * Emit a `references` edge to the capitalized receiver. Gated to languages
+     * where types are Capitalized by convention, and skipped when the access is a
+     * call's callee (the call extractor already links the method).
+     */
+    private extractStaticMemberRef;
+    private pushStaticMemberRef;
     /**
      * Find a `class_body` child of an `object_creation_expression` — the
      * marker for an anonymous class (`new T() { ... }`). Returns the body
@@ -216,6 +375,19 @@ export declare class TreeSitterExtractor {
      *      tree-sitter to interpret the namespace block as a function_definition,
      *      hiding real class/struct/enum nodes inside the "function body".
      */
+    /**
+     * Rocket route-registration macros — `routes![a::b::handler, c::d::other]`
+     * and `catchers![not_found]`. Tree-sitter leaves a macro body as a flat
+     * `token_tree` of raw tokens (`identifier`, `::`, `,`), so the handler paths
+     * are never seen as references and each handler fn looks like it has no caller
+     * — it's mounted by Rocket at runtime, not called by in-repo code, so its file
+     * shows 0 dependents. Walk the token tree, reconstruct each comma-separated
+     * path, and emit a `references` edge; the Rust path resolver
+     * (`resolveRustPathReference`) then links it to the handler fn. The handler
+     * names are explicit in source, so this is precise static extraction, not a
+     * heuristic — no false edges (resolution still validates each path).
+     */
+    private extractRustRouteMacro;
     private visitFunctionBody;
     /**
      * Extract inheritance relationships
@@ -234,6 +406,11 @@ export declare class TreeSitterExtractor {
      * Languages that support type annotations (TypeScript, etc.)
      */
     private readonly TYPE_ANNOTATION_LANGUAGES;
+    /**
+     * PHP pseudo-types and `self`/`static`/`parent` that aren't project symbols.
+     * (Scalar primitives parse as `primitive_type` and are skipped structurally.)
+     */
+    private readonly PHP_PSEUDO_TYPES;
     /**
      * Built-in/primitive type names that shouldn't create references
      */
@@ -256,12 +433,35 @@ export declare class TreeSitterExtractor {
      * `tuple_type`, …) — none of which are `type_identifier`. Closes #381.
      */
     private extractCsharpTypeRefs;
+    /**
+     * Record the dependencies declared by a C# PRIMARY CONSTRUCTOR
+     * (`class Svc(IRepo repo, [FromKeyedServices("k")] ICache cache) { … }`,
+     * C# 12+). The parameter list hangs off the class/struct/record declaration
+     * as an unnamed-field `parameter_list` child (not the `parameters` field a
+     * method uses), so it's found by node type. Each parameter's declared type
+     * becomes a `references` edge from the owning type — these are exactly the
+     * services a DI-registered type depends on, so impact/blast-radius and
+     * "who depends on this contract" now see them. No-op when there's no primary
+     * constructor. (#237)
+     */
+    private extractCsharpPrimaryCtorParamRefs;
     /**
      * Walk a C# subtree that is KNOWN to be in a type position
      * (return type, parameter type, property type, field type, generic
      * argument). Identifiers here are type names, not parameter names.
      */
     private walkCsharpTypePosition;
+    /**
+     * Extract PHP type references from a method/function/property declaration.
+     * Walks ONLY type positions: each parameter's type child (inside
+     * `formal_parameters`), the return type, and a property's type — all
+     * `named_type` / `optional_type` / `union_type` / … direct children. Parameter
+     * and property NAMES are `variable_name` (`$x`), never type nodes, so they
+     * can't be mis-emitted.
+     */
+    private extractPhpTypeRefs;
+    /** Walk a PHP subtree KNOWN to be in a type position; emit class/interface refs. */
+    private walkPhpTypePosition;
     /**
      * Extract type references from a variable's type annotation.
      */
@@ -301,6 +501,17 @@ export declare class TreeSitterExtractor {
      * Extract function calls from a Pascal expression
      */
     private extractPascalCall;
+    /**
+     * Extract a PAREN-LESS Pascal method/procedure call (`Obj.Method;`,
+     * `TFoo.GetInstance.DoIt;`). Pascal lets a no-arg method drop its parens, so it
+     * parses as a bare `exprDot` (not an `exprCall`). A bare `exprDot` is
+     * syntactically identical to a field/property access, so this is only ever
+     * called for a STATEMENT-level exprDot (caller-gated): a bare `Obj.Field;`
+     * statement is a no-op, so a statement-level dot expression is a call. (An
+     * exprDot in assignment LHS/RHS or a condition is left alone — there it really
+     * can be a field/property read.)
+     */
+    private extractPascalParenlessCall;
     /**
      * Recursively visit a Pascal block/statement tree for call expressions
      */

package/dist/extraction/vue-extractor.d.ts

@@ -32,5 +32,20 @@ export declare class VueExtractor {
      * Process a script block by delegating to TreeSitterExtractor
      */
     private processScriptBlock;
+    /**
+     * Extract component usages from the Vue `<template>`.
+     *
+     * PascalCase tags (`<Modal>`, `<Button />`) and kebab-case tags
+     * (`<my-button>`) both represent component instantiations — analogous to
+     * function calls in imperative code. Capturing them creates parent→child
+     * component edges and lets `callers` / `impact` see a component that is
+     * only ever used in markup. Vue's extractor previously parsed only the
+     * `<script>` block, so these usages produced no edge at all (#629).
+     *
+     * HTML elements (lowercase, no hyphen) and Vue built-ins are skipped.
+     * Unmatched names create no edge during resolution, so converting
+     * kebab-case is safe even for native custom elements.
+     */
+    private extractTemplateComponents;
 }
 //# sourceMappingURL=vue-extractor.d.ts.map

package/dist/index.d.ts

@@ -158,8 +158,8 @@ export declare class CodeGraph {
      */
     getPendingFiles(): PendingFile[];
     /**
-     * Resolves once the file watcher has finished its initial chokidar scan.
-     * Useful for tests that need a deterministic boundary before asserting on
+     * Resolves once the file watcher has installed its watch set. Useful for
+     * tests that need a deterministic boundary before asserting on
      * `getPendingFiles()`. Resolves immediately when no watcher is active.
      */
     waitUntilWatcherReady(timeoutMs?: number): Promise<void>;
@@ -171,6 +171,30 @@ export declare class CodeGraph {
         modified: string[];
         removed: string[];
     };
+    /**
+     * Most recent index timestamp (ms since epoch) across all tracked files, or
+     * null when nothing is indexed yet. Lets library consumers check index
+     * freshness without shelling out to `codegraph status --json`. (#329)
+     */
+    getLastIndexedAt(): number | null;
+    /**
+     * Which engine built the current index: the package version + extraction
+     * version stamped at the last full `indexAll`. Either field is null for an
+     * index built before stamping existed (treated as stale). See
+     * `extraction-version.ts` and `isIndexStale()`.
+     */
+    getIndexBuildInfo(): {
+        version: string | null;
+        extractionVersion: number | null;
+    };
+    /**
+     * True when the on-disk index was built by an engine whose extraction is
+     * older than the one now running — i.e. a re-index would add data a migration
+     * can't backfill. False when there's no index yet (nothing to refresh) or the
+     * stamp is current. This is the signal behind `codegraph status`'s re-index
+     * hint and `codegraph upgrade`'s reminder.
+     */
+    isIndexStale(): boolean;
     /**
      * Extract nodes and edges from source code (without storing)
      */
@@ -237,6 +261,14 @@ export declare class CodeGraph {
      * Search nodes by text
      */
     searchNodes(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * Normalized project-name tokens (go.mod / package.json / repo dir) used to
+     * down-weight the non-discriminative project name in search ranking (#720).
+     * Exposed so explore can exclude it from the PascalCase type-disambiguation
+     * bias, which would otherwise pull overloaded tokens toward whichever stack
+     * embeds the project name.
+     */
+    getProjectNameTokens(): Set<string>;
     /**
      * Find the project's "primary route file" — the file with the densest
      * concentration of framework-emitted `route` nodes (≥3 routes, ≥30%

package/dist/installer/instructions-template.d.ts

@@ -1,18 +1,41 @@
 /**
- * Marker constants for the legacy agent-instructions block.
+ * The marker-fenced agent-instructions block the installer writes into each
+ * agent's instructions file (CLAUDE.md / AGENTS.md / GEMINI.md).
  *
- * Codegraph used to write a `## CodeGraph` usage guide into each
- * agent's instructions file (CLAUDE.md / AGENTS.md / GEMINI.md /
- * codegraph.mdc / Kiro steering doc). That duplicated the guidance the
- * MCP server already emits in its `initialize` response — every agent
- * read the same playbook twice each turn (issue #529). The installer no
- * longer writes an instructions file; the MCP server instructions in
- * `mcp/server-instructions.ts` are the single source of truth.
+ * History: pre-#529 the installer wrote a full usage playbook here, which
+ * duplicated the MCP `initialize` instructions for the main agent — so it
+ * was removed and `mcp/server-instructions.ts` became the single source of
+ * truth. A much smaller block returned for #704, because the MCP
+ * instructions cannot reach two audiences that the instructions FILE does
+ * reach:
  *
- * These markers are retained so install (self-heal on upgrade) and
- * uninstall can find and strip the block a previous install wrote.
+ *  - **Task-tool subagents** — they receive the project instructions file
+ *    in their context but NOT the MCP initialize instructions. They hold
+ *    the codegraph MCP tools only as deferred names and rarely think to
+ *    load them: measured on a forced-delegation flow question (excalidraw,
+ *    sonnet, high effort), subagents loaded + used codegraph in ~1 of 9
+ *    runs without this block, and consistently with it — including runs
+ *    with zero Read/grep fallback.
+ *  - **Non-MCP harnesses** — agents with no MCP client at all can still
+ *    run the `codegraph explore` / `codegraph node` CLI, which prints the
+ *    same output as the MCP tools.
+ *
+ * Keep this block SHORT. The main agent reads it every turn on top of the
+ * server instructions — the #529 duplication-cost argument still bounds
+ * its size. Command names and the two surfaces, nothing more.
  */
-/** Markers used by the marker-based section removal. */
+/** Markers used by the marker-based section write/removal. */
 export declare const CODEGRAPH_SECTION_START = "<!-- CODEGRAPH_START -->";
 export declare const CODEGRAPH_SECTION_END = "<!-- CODEGRAPH_END -->";
+/**
+ * The full block, markers included, exactly as written to disk.
+ *
+ * The wording is deliberately CONDITIONAL ("in repositories indexed by…"):
+ * a global install writes this into a user-scope file (~/.claude/CLAUDE.md,
+ * ~/.codex/AGENTS.md) that applies to every project the user opens —
+ * including unindexed ones, where an unconditional "this repository is
+ * indexed" claim would send subagents into failing codegraph calls (the
+ * noise the unindexed-session policy exists to prevent).
+ */
+export declare const CODEGRAPH_INSTRUCTIONS_BLOCK = "<!-- CODEGRAPH_START -->\n## CodeGraph\n\nIn repositories indexed by CodeGraph (a `.codegraph/` directory exists at the repo root), reach for it BEFORE grep/find or reading files when you need to understand or locate code:\n\n- **MCP tools** (when available): `codegraph_explore` answers most code questions in one call \u2014 the relevant symbols' verbatim source plus the call paths between them. `codegraph_node` returns one symbol's source + callers, or reads a whole file with line numbers. If the tools are listed but deferred, load them by name via tool search.\n- **Shell** (always works): `codegraph explore \"<symbol names or question>\"` and `codegraph node <symbol-or-file>` print the same output.\n\nIf there is no `.codegraph/` directory, skip CodeGraph entirely \u2014 indexing is the user's decision.\n<!-- CODEGRAPH_END -->";
 //# sourceMappingURL=instructions-template.d.ts.map