gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

package/dist/_shared/scope-resolution/types.d.ts

@@ -27,8 +27,20 @@ import type { SymbolDefinition } from './symbol-definition.js';
 export type ScopeId = string;
 /** Stable symbol-definition identifier (graph nodeId). */
 export type DefId = string;
-/** Kinds of lexical scope a `Scope` node can represent. */
-export type ScopeKind = 'Module' | 'Namespace' | 'Class' | 'Function' | 'Block' | 'Expression';
+/**
+ * Kinds of lexical scope a `Scope` node can represent.
+ *
+ * `Object` is a hoist boundary ONLY: an object/record literal body
+ * (TS/JS `{...}`, Kotlin anonymous `object {...}`). Members are
+ * reachable via property access, never as bare identifiers, so
+ * scope-chain walkers (`scope/walkers.ts`) must skip an `Object`
+ * scope's own bindings while still traversing past it to the parent
+ * (#2545/#2551) -- unlike `Block`, where a nested closure legitimately
+ * DOES see a sibling `let`/`const` from an enclosing `if`/`for`/`while`,
+ * a nested closure inside an object literal must NOT see a sibling
+ * property's name as a free identifier.
+ */
+export type ScopeKind = 'Module' | 'Namespace' | 'Class' | 'Function' | 'Block' | 'Expression' | 'Object';
 /** Source-text range. 1-based `startLine`/`endLine`; 0-based `startCol`/`endCol`. */
 export interface Range {
     readonly startLine: number;
@@ -85,6 +97,97 @@ export type ParsedImport =
     readonly localName: string;
     readonly importedName: string;
     readonly targetRaw: string;
+    /** Provider-specific imported symbol category when module and symbol
+     * namespaces have distinct resolution rules (for example PHP).
+     *
+     * **Not** the same fact as {@link ParsedImport.typeOnly} — see the note
+     * on `typeOnly` below, which is documented on this variant. */
+    readonly importedSymbolKind?: 'type' | 'function' | 'const';
+    /**
+     * Is this import ERASED before the module ever runs?
+     *
+     * TypeScript `import type { X } from './m'` and `import { type X }` are
+     * deleted by `tsc`: no `require`/`import` for `./m` survives in the
+     * emitted JavaScript, so the pair cannot force a module-INITIALIZATION
+     * order and cannot participate in an init cycle. That is the one thing
+     * `check --cycles` exists to find, so the fact has to survive from the
+     * syntax down to the emitted `IMPORTS` edge — see `ImportEdge.typeOnly`
+     * and `graph-bridge/imports-to-edges.ts`.
+     *
+     * **Distinct from `importedSymbolKind: 'type'`, which is NOT a substitute.**
+     * That field is a resolution-NAMESPACE category (PHP's `use function` /
+     * `use const` split), it exists only on this variant, and it says "the
+     * thing imported is a type". A symbol being a type says nothing about
+     * whether the import STATEMENT is erased, and PHP erases nothing at all.
+     * This field is about the statement's runtime existence, not the symbol's
+     * category.
+     *
+     * Set only by providers whose syntax marks it. Absent everywhere else,
+     * which reads as "not erased" — the fail-safe direction, since it only
+     * makes `check --cycles` over-report.
+     *
+     * That fail-safe matters more than it first looks, because an explicit
+     * `type` is a SUFFICIENT signal of erasure and not a necessary one. With
+     * neither `verbatimModuleSyntax` nor `importsNotUsedAsValues: preserve`
+     * set — this repo sets neither — `tsc` also elides a plain
+     * `import { SomeInterface }` whose bindings are every one of them used in
+     * type position. Those statements are erased at run time and carry no
+     * marker, so they stay tagged as initializing and `check --cycles` can
+     * still report a cycle that cannot exist. Closing that gap needs
+     * whole-program binding USE information, not import syntax, which is why
+     * this field stops at what the syntax states.
+     */
+    readonly typeOnly?: boolean;
+    /**
+     * Was this import written inside a function body — so that it runs only
+     * when something CALLS that function, never while the module itself is
+     * initializing?
+     *
+     * Python's `def f(): from x import Y` and a CommonJS
+     * `function f() { const { Y } = require('./x'); }` are the spellings.
+     * Both are syntactically ordinary imports — no `kind` tells them apart
+     * from a top-level one, and nothing about the target does either. Only
+     * their POSITION defers them.
+     *
+     * Not every language's imports are like that, and the rule is wrong for
+     * the ones that are not: Rust's `use` and C/C++'s `#include` are legal
+     * in a function body and are deferred by NOTHING, because neither is an
+     * executed statement. Those providers opt out — see
+     * `LanguageProvider.importsExecuteWhereWritten`, below.
+     *
+     * **Why this cannot be re-derived downstream — the whole reason the
+     * field exists.** The natural place to decide it looks like the graph
+     * bridge, by walking the scope the finalized edges hang off; that is
+     * exactly what `graph-bridge/imports-to-edges.ts` once attempted, and it
+     * is dead code by construction. `finalize-algorithm.ts:295` publishes
+     * every file's finalized edges as
+     * `linkedByScope.set(file.moduleScope, …)`, so the map the bridge
+     * receives is keyed by the file's **Module** scope and by nothing else:
+     * the walk starts at a `Module` every time and answers `false` for every
+     * import in the tree. Finalize cannot recover the position either —
+     * `FinalizeFile.parsedImports` is a flat per-file `ParsedImport[]` with
+     * no scope attached. The extractor is the last stage that still knows
+     * where the statement sat (`scope-extractor.ts`, Pass 3), so it marks the
+     * fact here and it rides the edge from there — see
+     * {@link ImportEdge.runsOnlyWhenCalled}.
+     *
+     * Consumed by `check --cycles`, which asks "can these modules be
+     * initialized in any order?". A deferred import carries no
+     * initialization order, and deferring one is the standard way to BREAK
+     * an init cycle, so counting it reports the fix as the bug.
+     *
+     * Set by the central extractor for every language, not by providers —
+     * except that a provider may declare that its imports do not execute
+     * where they are written (`LanguageProvider.importsExecuteWhereWritten:
+     * false`) and be skipped entirely. C, C++, Rust and COBOL do. A `#include`
+     * or a `use` inside a function body is not deferred: the header is
+     * spliced and the path alias is resolved before anything runs, so the
+     * pair really is a dependency and the cycle it can form is real.
+     *
+     * Absent reads as "runs at initialization" — the fail-safe direction,
+     * since it only makes `check --cycles` over-report.
+     */
+    readonly runsOnlyWhenCalled?: boolean;
     /**
      * Set by providers when `targetRaw` already names the imported symbol
      * rather than only its containing module. Consumers that compose
@@ -92,6 +195,40 @@ export type ParsedImport =
      * duplicating `importedName`.
      */
     readonly targetIncludesImportedName?: boolean;
+    /**
+     * Set by providers whose import syntax *also* republishes the name from
+     * the importing module, so a third file can import it from there.
+     *
+     * Python has no dedicated re-export form: a module-level
+     * `from pkg.impl import X` binds `X` locally **and** publishes it as
+     * `pkg.X`, which is the standard way a package `__init__.py` declares
+     * its public surface. Languages with an explicit form (TS `export … from`,
+     * Rust `pub use`) emit `kind: 'reexport'` instead and leave this unset.
+     *
+     * **The flag must track actual republication, not syntax.** Only a
+     * module-level statement publishes: the same `from m import X` inside a
+     * `def` or `class` body binds locally and puts nothing in the module
+     * namespace, so flagging it fabricates a re-export of a name no importer
+     * can reach. `if` / `try` / `for` / `with` do not suppress it — Python
+     * has no block scope. A provider that cannot tell these apart at
+     * interpret time must carry the fact down from its capture emitter,
+     * where the syntax node is still available.
+     *
+     * **Why not `kind: 'reexport'`.** Not because that form drops the local
+     * binding — `materializeBindings` creates a module-scope `BindingRef`
+     * for every linked edge, re-export included. It is that `reexport`
+     * changes what the binding *is*: `origin` flips to `'reexport'`, which
+     * carries different evidence weight and `ORIGIN_PRIORITY`, and it
+     * misreports the parse-time syntax Python actually wrote. A flag adds
+     * the export-surface fact without restating the import as something the
+     * source does not say.
+     *
+     * Consumed by `buildReexportClosures` (`finalize-algorithm.ts`), which
+     * also documents how ambiguous duplicates of one published name are
+     * handled — the precedence rules that hold for an explicit re-export do
+     * not carry over.
+     */
+    readonly reexportsName?: boolean;
 }
 /**
  * Per-name import with rename.
@@ -107,7 +244,19 @@ export type ParsedImport =
     readonly alias: string;
     readonly targetRaw: string;
     /** See the same field on the `named` variant. */
+    readonly importedSymbolKind?: 'type' | 'function' | 'const';
+    /** See the same field on the `named` variant — including why it is not
+     *  interchangeable with `importedSymbolKind`. Reaches this variant from
+     *  `import type D from './m'` and `import { type X as Y } from './m'`. */
+    readonly typeOnly?: boolean;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  Python's `def f(): from x import Y as Z` and a CommonJS
+     *  `function f() { const { Y: Z } = require('./x'); }`. */
+    readonly runsOnlyWhenCalled?: boolean;
+    /** See the same field on the `named` variant. */
     readonly targetIncludesImportedName?: boolean;
+    /** See the same field on the `named` variant. */
+    readonly reexportsName?: boolean;
 }
 /**
  * Qualified module handle, with or without rename. `importedName` is the
@@ -127,6 +276,12 @@ export type ParsedImport =
     /** Module being aliased (e.g. `numpy` in `import numpy as np`). */
     readonly importedName: string;
     readonly targetRaw: string;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  TypeScript `import type * as N from './m'`. */
+    readonly typeOnly?: boolean;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  Python's `def f(): import numpy as np`. */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Syntactically-detectable parse-time re-export. Finalize may still produce
@@ -148,6 +303,19 @@ export type ParsedImport =
     readonly targetRaw: string;
     /** Set when the re-export renames the symbol (e.g. `export { X as Y } from './y'`). */
     readonly alias?: string;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  TypeScript `export type { X } from './y'` and `export { type X } from './y'`. */
+    readonly typeOnly?: boolean;
+    /** See the same field on the `named` variant. NO spelling reaches this
+     *  variant today: the two providers that emit `reexport` are TypeScript
+     *  / JavaScript, whose `export … from` is a module-top-level-only
+     *  declaration, and Rust, whose `pub use` is a compile-time path alias
+     *  that its provider exempts from the position rule outright
+     *  (`LanguageProvider.importsExecuteWhereWritten`). Kept because the
+     *  extractor sets the field with no `switch` on `kind`, so a re-export
+     *  form that IS an executed statement would be tagged the moment one
+     *  appears — not because anything sets it now. */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Wildcard import — brings every exported name from the target module into
@@ -159,10 +327,26 @@ export type ParsedImport =
  *   - Python `from foo import *`   → `{ kind: 'wildcard', targetRaw: 'foo' }`
  *   - JS `export * from './foo'`   → `{ kind: 'wildcard', targetRaw: './foo' }`
  *   - Rust `pub use foo::*`         → `{ kind: 'wildcard', targetRaw: 'foo' }`
+ *
+ * No `typeOnly` here on purpose. The one syntax that would set it,
+ * TypeScript 5.0's `export type * from './m'`, is not parsed by the
+ * vendored tree-sitter-typescript grammar — it yields an `ERROR` node
+ * holding the bare `type` token, so the fact is not readable at the
+ * statement level (see `typescript/import-decomposer.ts`). Add the field
+ * with the grammar that can express it, not before.
  */
  | {
     readonly kind: 'wildcard';
     readonly targetRaw: string;
+    /** See the same field on the `named` variant. Present here although
+     *  `typeOnly` is not: erasure is a syntactic fact this spelling cannot
+     *  express, but POSITION is not — Ruby's `def f; require './m'; end` is
+     *  a wildcard (everything in the required file becomes visible) and IS
+     *  deferred. Python cannot reach it: `from x import *` inside a `def` is
+     *  a SyntaxError. Rust's fn-local `use foo::*` is legal but not
+     *  deferred — `use` does not execute
+     *  (`LanguageProvider.importsExecuteWhereWritten`). */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Runtime-computed target — the import path is not a static literal at
@@ -179,6 +363,9 @@ export type ParsedImport =
     readonly localName: string;
     /** Source text of the unresolved expression when available; `null` otherwise. */
     readonly targetRaw: string | null;
+    /** See the same field on the `named` variant. Set by position like every
+     *  other variant; this kind links no target, so nothing reads it here. */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Lazy / dynamic import whose target IS a static string literal at parse
@@ -200,6 +387,10 @@ export type ParsedImport =
  | {
     readonly kind: 'dynamic-resolved';
     readonly targetRaw: string;
+    /** See the same field on the `named` variant. Redundant on this kind —
+     *  `import()` is already deferred wherever it is written — but set
+     *  uniformly, because position is decided without consulting `kind`. */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Bare-source / side-effect import that introduces no local name binding
@@ -215,6 +406,10 @@ export type ParsedImport =
  | {
     readonly kind: 'side-effect';
     readonly targetRaw: string;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  a bare CommonJS `function f() { require('./polyfill'); }` — the ESM
+     *  spelling `import './polyfill'` cannot, being top-level only. */
+    readonly runsOnlyWhenCalled?: boolean;
 };
 /**
  * Provider-interpreted type binding. The provider's `interpretTypeBinding`
@@ -225,8 +420,24 @@ export type ParsedImport =
 export interface ParsedTypeBinding {
     /** The name being bound (parameter name, `self`, assignment LHS, …). */
     readonly boundName: string;
-    /** The raw type name as written in source (`'User'`, `'models.User'`, …). */
+    /** The type name AFTER this provider's normalization (`'User'`,
+     *  `'models.User'`, …) — see `TypeRef.rawName`. */
     readonly rawTypeName: string;
+    /**
+     * Optional override for `TypeRef.declaredSpelling`, for a grammar that does
+     * not keep the whole written type under `@type-binding.type`.
+     *
+     * The scope extractor derives the spelling from that capture by default,
+     * which is right for every language whose type node spans the annotation.
+     * C++ is the exception: `User* repos` parses with the `*` on the DECLARATOR,
+     * so the type capture is a bare `User` and the container-ness the index step
+     * needs is nowhere in the captures the extractor reads. A provider that can
+     * reconstruct it exactly sets it here.
+     *
+     * Leave undefined otherwise — the extractor's derivation is preferred to a
+     * per-language reimplementation of it.
+     */
+    readonly declaredSpelling?: string;
     readonly source: TypeRef['source'];
 }
 /**
@@ -275,6 +486,37 @@ export interface ImportEdge {
     readonly kind: 'named' | 'alias' | 'namespace' | 'wildcard-expanded' | 'reexport' | 'dynamic-unresolved' | 'dynamic-resolved' | 'side-effect';
     /** Re-export chain, for provenance (e.g., `['./y']` when re-exported via `./y`). */
     readonly transitiveVia?: readonly string[];
+    /**
+     * The import is erased before the module runs — see `ParsedImport`'s
+     * `typeOnly` on the `named` variant for the full note, including why
+     * `importedSymbolKind: 'type'` is a different fact and not a substitute.
+     *
+     * Carried straight from the `ParsedImport` by `makeEdgeDrafts`. The edge is
+     * still emitted: a type-only import is a real source-level dependency that
+     * `impact` and `trace` must see, and editing the target still breaks the
+     * importer's typecheck. What the flag removes is the claim that the pair
+     * forces an INITIALIZATION order.
+     */
+    readonly typeOnly?: boolean;
+    /**
+     * The import was written inside a function body, so it runs only when that
+     * function is called — never during module initialization. See
+     * `ParsedImport`'s `runsOnlyWhenCalled` on the `named` variant for the full
+     * note, including why the consumer cannot re-derive this from the scope tree
+     * and therefore has to be told (`finalize-algorithm.ts:295`).
+     *
+     * Carried straight from the `ParsedImport` by `makeEdgeDrafts`, for the same
+     * reason `typeOnly` is: the edge is where `graph-bridge/imports-to-edges.ts`
+     * can still see it. The edge is still emitted either way — a deferred import
+     * is a real dependency. What the flag removes is the claim that the pair
+     * forces an INITIALIZATION order.
+     *
+     * Distinct from `kind === 'dynamic-resolved'`, which records the OTHER way an
+     * import can be deferred (`import('./m')`). Neither implies the other: a
+     * top-level `import()` is deferred with this flag unset, and a function-local
+     * `from x import Y` is deferred with an ordinary `named` kind.
+     */
+    readonly runsOnlyWhenCalled?: boolean;
     /** Set to `'unresolved'` when the SCC fixpoint could not link this edge. */
     readonly linkStatus?: 'unresolved';
 }
@@ -291,6 +533,11 @@ export interface BindingRef {
     readonly origin: 'local' | 'import' | 'namespace' | 'wildcard' | 'reexport';
     /** Non-null for non-local origins; carries the `ImportEdge` that brought the name into this scope. */
     readonly via?: ImportEdge;
+    /**
+     * Optional semantic visibility evidence supplied by a language hook.
+     * Shared resolution consumes this without inspecting language syntax.
+     */
+    readonly visibility?: 'static-member-import';
 }
 /**
  * A reference to a named type, anchored at its declaration site.
@@ -302,8 +549,36 @@ export interface BindingRef {
  * re-exports, and nested modules. Generics deferred to V2 via `typeArgs`.
  */
 export interface TypeRef {
-    /** The name as written in source (e.g., `'User'`, `'models.User'`, `'List'`). */
+    /**
+     * The type name AFTER the language's capture-time normalization — NOT
+     * necessarily what the source says. Every provider's `interpretTypeBinding`
+     * reduces the annotation before it gets here: TypeScript runs
+     * `stripGeneric` + `stripArraySuffix` to a FIXED POINT (`User[][]` → `User`),
+     * Go's `normalizeGoTypeName` drops `[]` and `map[K]`, C#/Python/Kotlin/Rust
+     * strip their single-arg collection wrappers. What survives is the name a
+     * class lookup can use (`'User'`, `'models.User'`, `'List'`).
+     *
+     * A consumer that needs the CONTAINER, not the element, must read
+     * `declaredSpelling` — see below.
+     */
     readonly rawName: string;
+    /**
+     * The annotation exactly as written, kept ONLY when `rawName` is not it.
+     *
+     * `rawName` alone cannot distinguish `repos: User[]` (a container the capture
+     * layer already reduced, so the position IS the element) from `grid: Grid`
+     * (an ordinary class the source happened to subscript). Both arrive as a bare
+     * class name that resolves. An index step reading only `rawName` therefore had
+     * no choice but to guess, and guessing "already reduced" typed `grid[0]` as
+     * `Grid` — a confidently WRONG owner for the next member.
+     *
+     * Absent when the provider's normalization was a no-op (nothing was lost, so
+     * `rawName` is already the written spelling), and absent for TypeRefs
+     * synthesized outside the capture path (a `this` receiver binding, a
+     * propagated return type). Consumers must treat absence as "no container
+     * evidence" and decline, never as "not a container".
+     */
+    readonly declaredSpelling?: string;
     /** Anchor for resolving `rawName` — the scope where the annotation/inference was written. */
     readonly declaredAtScope: ScopeId;
     readonly source: 'annotation' | 'parameter-annotation' | 'return-annotation' | 'self' | 'assignment-inferred' | 'constructor-inferred' | 'receiver-propagated';
@@ -332,6 +607,23 @@ export interface Scope {
     readonly imports: readonly ImportEdge[];
     /** Local type facts visible from this scope (parameter annotations, `self` binding, etc.). */
     readonly typeBindings: ReadonlyMap<string, TypeRef>;
+    /** Lexically bound names that may have no definition or type fact of their
+     * own (for example, an untyped function parameter). Consumers use this only
+     * as a shadowing barrier; it never resolves a symbol by itself. */
+    readonly lexicalNames?: ReadonlySet<string>;
+    /** Receiver names this scope BINDS rather than inherits — `this`, `self`, … (#2701).
+     *
+     *  A receiver walk (`findReceiverTypeBinding`) that reaches such a scope
+     *  without finding the name in `typeBindings` stops here and reports the
+     *  receiver unresolved, instead of continuing up and borrowing an enclosing
+     *  scope's binding. In JavaScript/TypeScript an ordinary `function` binds its
+     *  own `this` (ECMA-262 `[[ThisMode]]`) while an arrow inherits one, so
+     *  `this.m()` inside a nested `function` must NOT reach the enclosing class.
+     *
+     *  Left unset by every language whose closures capture the receiver
+     *  lexically, which is nearly all of them — the walk is unchanged there.
+     *  Populated from `LanguageProvider.scopeOwnsReceivers`. */
+    readonly ownsReceivers?: ReadonlySet<string>;
 }
 /**
  * One piece of evidence for a `Resolution`. Multiple signals corroborate a
@@ -372,7 +664,7 @@ export interface Reference {
     readonly toDef: DefId;
     /** Location of the reference in source. */
     readonly atRange: Range;
-    readonly kind: 'call' | 'read' | 'write' | 'type-reference' | 'inherits' | 'import-use' | 'macro';
+    readonly kind: 'call' | 'read' | 'write' | 'type-reference' | 'inherits' | 'import-use' | 'value-ref' | 'macro';
     readonly confidence: number;
     readonly evidence: readonly ResolutionEvidence[];
 }

package/dist/_shared/scope-resolution/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}

package/dist/cli/ai-context.d.ts

@@ -5,7 +5,7 @@
  * AGENTS.md is the standard read by Cursor, Windsurf, OpenCode, Codex, Cline, CodeBuddy, Qoder, etc.
  * CLAUDE.md is for Claude Code which only reads that file.
  */
-import { type GeneratedSkillInfo } from './skill-gen.js';
+import { type GeneratedSkillInfo } from './generated-skill.js';
 interface RepoStats {
     files?: number;
     nodes?: number;
@@ -47,7 +47,8 @@ export interface GitNexusContentOptions {
     skipSkills?: boolean;
     /** Project-relative path to the runner `gitnexus analyze` drops next to the
      *  index (#1945). Referenced by docs so a single CLI-neutral command resolves
-     *  the available runner (global `gitnexus` → `pnpm dlx` → `npx`) at call time. */
+     *  the available runner (global `gitnexus` → `pnpm dlx` → `bunx` → `npx`) at
+     *  call time. */
     runnerPath?: string;
     /** Default branch for the regression-compare example (#243). Configurable so
      *  projects on `develop`/`master`/etc. don't get `base_ref: "main"` rewritten
@@ -63,6 +64,13 @@ export interface GitNexusContentOptions {
     hasPdg?: boolean;
 }
 export declare function generateGitNexusContent(projectName: string, stats: RepoStats, opts?: GitNexusContentOptions): string;
+/**
+ * Some agents read skills from a repo-local `.agents/skills/` directory and
+ * prefer it over the global `~/.agents/skills/` install. When the repo contains
+ * an `.agents/` directory, skills written to `.claude/skills/` are mirrored
+ * there too so those agents serve the up-to-date copies.
+ */
+export declare function shouldMirrorSkillsToAgents(repoPath: string): Promise<boolean>;
 /**
  * Generate AI context files after indexing
  */