From 3963c497dd2a150ff607122a250adcc809c4d49d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gerg=C5=91=20Magyar?= Date: Mon, 8 Jun 2026 07:20:12 +0100 Subject: [PATCH 1/4] fix(parse): correct worker-pool docs drift + surface worker-side stack on crash (#2068) (#2070) --- ARCHITECTURE.md | 14 +- README.md | 4 +- gitnexus/bench/parse-throughput.md | 43 +++-- gitnexus/package-lock.json | 1 - gitnexus/package.json | 1 - gitnexus/src/cli/analyze.ts | 16 ++ gitnexus/src/core/ingestion/ast-cache.ts | 77 -------- gitnexus/src/core/ingestion/call-processor.ts | 88 +-------- .../src/core/ingestion/export-detection.ts | 3 +- .../src/core/ingestion/filesystem-walker.ts | 22 --- .../ingestion/languages/python/captures.ts | 7 +- .../pipeline-phases/orm-extraction.ts | 106 ----------- .../ingestion/pipeline-phases/parse-impl.ts | 11 -- .../core/ingestion/workers/parse-worker.ts | 18 +- .../src/core/ingestion/workers/worker-pool.ts | 38 +++- gitnexus/src/core/lbug/lbug-adapter.ts | 33 +++- gitnexus/src/core/lbug/pool-adapter.ts | 56 +++++- gitnexus/src/core/lbug/query-result-utils.ts | 31 +++ gitnexus/src/mcp/local/local-backend.ts | 15 +- gitnexus/src/types/pipeline.ts | 9 +- gitnexus/test/integration/lbug-pool.test.ts | 80 ++++++++ gitnexus/test/unit/ast-cache.test.ts | 95 ---------- .../test/unit/lbug-query-result-utils.test.ts | 45 +++++ .../test/unit/lbug-readonly-error.test.ts | 28 +++ .../test/unit/worker-pool-error-stack.test.ts | 176 ++++++++++++++++++ 25 files changed, 562 insertions(+), 455 deletions(-) delete mode 100644 gitnexus/src/core/ingestion/ast-cache.ts delete mode 100644 gitnexus/src/core/ingestion/pipeline-phases/orm-extraction.ts create mode 100644 gitnexus/src/core/lbug/query-result-utils.ts delete mode 100644 gitnexus/test/unit/ast-cache.test.ts create mode 100644 gitnexus/test/unit/lbug-query-result-utils.test.ts create mode 100644 gitnexus/test/unit/worker-pool-error-stack.test.ts diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index d90d132f6..01013c71c 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -15,7 +15,7 @@ Monorepo: **CLI/MCP** (`gitnexus/`) + **browser UI** (`gitnexus-web/`). ## End-to-end flow: index → graph → tools -1. **Ingestion** — `analyze.ts` → `runFullAnalysis` (`run-analyze.ts`) → `runPipelineFromRepo` (`pipeline.ts`). DAG of 12 phases builds a `KnowledgeGraph` in memory, then loads into LadybugDB under `.gitnexus/`. Repo registered in `~/.gitnexus/registry.json` for MCP discovery. +1. **Ingestion** — `analyze.ts` → `runFullAnalysis` (`run-analyze.ts`) → `runPipelineFromRepo` (`pipeline.ts`). DAG of 14 phases builds a `KnowledgeGraph` in memory, then loads into LadybugDB under `.gitnexus/`. Repo registered in `~/.gitnexus/registry.json` for MCP discovery. 2. **Persistence** — `repo-manager.ts` (paths, registry, KuzuDB cleanup). `lbug-adapter.ts` (graph load, queries, embedding batches). @@ -101,7 +101,7 @@ scan → structure → [markdown, cobol] → parse → [routes, tools, orm] | `communities` | `communities.ts` | `mro`, `pruneLocalSymbols`, `structure` | Community nodes + MEMBER_OF edges (Leiden algorithm) | | `processes` | `processes.ts` | `communities`, `routes`, `tools`, `pruneLocalSymbols`, `structure` | Process nodes + STEP_IN_PROCESS edges | -**Non-phase files in the same directory:** `parse-impl.ts`, `cross-file-impl.ts` (implementation), `wildcard-synthesis.ts` (whole-module import expansion), `orm-extraction.ts` (sequential ORM fallback), `types.ts`, `runner.ts`, `index.ts`. +**Non-phase files in the same directory:** `parse-impl.ts`, `cross-file-impl.ts` (implementation), `wildcard-synthesis.ts` (whole-module import expansion), `types.ts`, `runner.ts`, `index.ts`. ### DAG runner @@ -121,7 +121,7 @@ scan → structure → [markdown, cobol] → parse → [routes, tools, orm] - **Single graph accumulator** — all phases mutate the same `KnowledgeGraph` in `ctx`; the graph is the primary output. - **Typed phase access** — `getPhaseOutput(deps, 'name')` for type-safe upstream results. - **Binding accumulator lifecycle** — created in `parse`, disposed by `crossFile` (in `finally`). No other phase should take ownership. -- **Skippable phases** — `skipGraphPhases` omits MRO/communities/processes (faster tests); `pruneLocalSymbols` still runs (it is graph cleanup, not analysis). `skipWorkers` forces sequential parsing. +- **Skippable phases** — `skipGraphPhases` omits MRO/communities/processes (faster tests); `pruneLocalSymbols` still runs (it is graph cleanup, not analysis). `skipWorkers` is no longer a sequential escape hatch — it (like `--workers 0` / `GITNEXUS_WORKER_POOL_SIZE=0`) is rejected with an actionable error, since the worker pool is the sole parse path (§ Chunked parse-and-resolve). - **Local-symbol pruning** — `pruneLocalSymbols` removes inert block-local value symbols after scope resolution has consumed them. Opt out per-call with `PipelineOptions.keepLocalValueSymbols` or globally with the `GITNEXUS_KEEP_LOCAL_VALUE_SYMBOLS` env var. ### How to add a new phase @@ -202,7 +202,7 @@ Language-agnostic scope-resolution resolver. This is the resolution path for eve ``` Orchestrator: `runScopeResolution(input, provider)` in `scope-resolution/pipeline/run.ts`. -Pipeline phase: `scopeResolutionPhase` in `scope-resolution/pipeline/phase.ts` — iterates the registered `SCOPE_RESOLVERS`, reads per-file Trees from the parse phase's `scopeTreeCache`, disposes the cache at the end. +Pipeline phase: `scopeResolutionPhase` in `scope-resolution/pipeline/phase.ts` — iterates the registered `SCOPE_RESOLVERS` over the worker-serialized `ParsedFile`s. (Per-language `emitScopeCaptures` hooks may reuse a cached Tree via the orchestrator's `treeCache`, but in worker-pool runs that cache is empty — Trees can't cross MessageChannels — so they consume the pre-extracted `ParsedFile` instead; § Performance notes.) ### `ScopeResolver` contract @@ -251,7 +251,7 @@ CI auto-discovers the set via `tsx`. No workflow edit required. ### Performance notes -- **Cross-phase Tree cache**: parse phase writes Trees into `scopeTreeCache` (separate from the chunk-local `astCache`) ONLY for languages with `emitScopeCaptures`. Scope-resolution reads from it to skip the second parse. Cleared at end of the phase. Workers leave the cache empty — Trees can't cross MessageChannels; cache miss = fresh parse. `PROF_SCOPE_RESOLUTION=1` emits hit/miss counters and a worker-engaged warning. +- **Cross-phase Tree cache**: the orchestrator's `treeCache` (`RunScopeResolutionInput.treeCache`) lets a scope-resolution per-language hook (`emitScopeCaptures`) reuse a tree instead of re-parsing. Workers leave it empty — Trees can't cross MessageChannels — so in normal (worker-pool) runs scope-resolution does NOT rely on it: workers serialize each file's `ParsedFile` (+ capture side-channel) and stream them in, so scope-resolution consumes the pre-extracted artifact rather than re-parsing on the main thread (§ Chunked parse-and-resolve). `PROF_SCOPE_RESOLUTION=1` emits hit/miss counters and a worker-engaged warning. - **Typed relationship iteration**: heritage + MRO walk only the EXTENDS / IMPLEMENTS / HAS_METHOD edges via `iterRelationshipsByType`, not the full relationship map. - **Workspace-resolution-index**: O(1) `findOwnedMember` / `findExportedDef` / `classScopeByDefId` built once per run. - **SCC-ordered cross-file return-type propagation** (PR #1050): `propagateImportedReturnTypes` walks `indexes.sccs` in reverse-topological order (leaves first), so multi-hop alias chains like `models.User → service.user → app.user` collapse to the terminal class in a single linear pass. Within each importer, the source module's `typeBindings` is chain-followed BEFORE mirroring (so we mirror terminal types, not intermediate refs), and the importer's own `typeBindings` is chain-followed AFTER mirroring (so local `const x = importedFn()` resolves before downstream importers run). Cyclic SCCs reach a partial fixpoint within a single pass without iterating to convergence — see the `ts-circular` cross-file-binding fixture which only asserts pipeline-no-throw. PROF output (`PROF_SCOPE_RESOLUTION=1`) splits `finalize` from `propagate` so quadratic regressions in the chain-follow surface independently. @@ -314,7 +314,7 @@ Unified 3-tier algorithm (`model/resolution-context.ts`), per-language `importSe ### Chunked parse-and-resolve `parse` processes files in ~20 MB byte-budget chunks to bound memory. Per chunk: -1. Worker pool dispatches files (or sequential fallback via `skipWorkers`) +1. Worker pool dispatches files (the sole parse path — there is no sequential fallback; `skipWorkers`, `--workers 0`, and `GITNEXUS_WORKER_POOL_SIZE=0` are rejected with an actionable error) 2. Each worker: detect language → load grammar → run queries → return unified `ParseWorkerResult` 3. Synthesize wildcard bindings (`wildcard-synthesis.ts`) 4. Resolve imports @@ -324,6 +324,8 @@ Inheritance edges are emitted later, by the scope-resolution phase (`preEmitInhe Workers: `workers/worker-pool.ts`, `workers/parse-worker.ts`. +**Worker-serialized ParsedFiles (#2038).** To index very large repos (e.g. the Linux kernel) without OOM, the worker pool is the *sole* parse path and workers serialize each file's `ParsedFile` (plus its capture side-channel) in parallel, streaming them to scope-resolution through a disk-backed store. Scope-resolution consumes the pre-extracted artifact instead of re-parsing every file on the main thread — tree-sitter's native input buffers are not GC-reclaimable, so the former main-thread re-parse leaked native memory until the process died. Pool creation is lazy / cache-miss-gated, so a warm all-cache-hit run replays cached worker output without spawning a worker (hence `usedWorkerPool` can be false even when the repo has parseable files). + ### Inheritance and MRO Inheritance is captured by the `@reference.inherits` tag and emitted by the scope-resolution phase: `preEmitInheritanceEdges` resolves each base in scope, then `emitHeritageEdges` writes the `EXTENDS`/`IMPLEMENTS` edges. The phase then computes method resolution order via each `ScopeResolver`'s `buildMro` hook, feeding a `MethodDispatchIndex` used for owner-scoped lookups. Per-language strategy: diff --git a/README.md b/README.md index 28229c98c..2df823d9a 100644 --- a/README.md +++ b/README.md @@ -236,7 +236,7 @@ gitnexus analyze --embeddings [limit] # Enable embedding generation (slower, be gitnexus analyze --verbose # Log skipped files when parsers are unavailable gitnexus analyze --worker-timeout 60 # Increase worker idle timeout for slow parses gitnexus analyze --wal-checkpoint-threshold 67108864 # 64 MiB. Control LadybugDB WAL auto-checkpoint threshold (default: 67108864 = 64 MiB; -1 keeps Ladybug stock ~16 MiB) -gitnexus analyze --workers # Parse worker pool size (default: cores-1, capped at 16; 0 = sequential) +gitnexus analyze --workers # Parse worker pool size (>=1; default: cores-1, capped at 16, auto-sized to the repo). 0 is rejected — there is no sequential mode. gitnexus mcp # Start MCP server (stdio) — serves all indexed repos gitnexus serve # Start local HTTP server (multi-repo) for web UI connection gitnexus list # List all indexed repositories @@ -314,7 +314,7 @@ Most `analyze` knobs are also CLI flags (`--workers`, `--worker-timeout`, `--max | Variable | Default | Effect | Tune when… | | -------------------------------------- | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | -| `GITNEXUS_WORKER_POOL_SIZE` | `cores - 1`, capped at 16 | Parse worker pool size. `0` disables the pool (sequential fallback). Equivalent to `--workers `. | Constrained containers (cgroup CPU limits), CI runners with explicit quotas, or debugging a worker-only crash via `0`. | +| `GITNEXUS_WORKER_POOL_SIZE` | `cores - 1`, capped at 16 | Parse worker pool size (must be ≥ 1). Equivalent to `--workers `. The worker pool is the sole parse path — there is no sequential parser, so `0` is rejected with an actionable error (the pool self-heals via quarantine + respawn). | Constrained containers (cgroup CPU limits) or CI runners with explicit quotas. To narrow down a worker crash set `1` for a single-worker pool — not `0`. | | `GITNEXUS_PARSE_CHUNK_CONCURRENCY` | `2` | Number of chunks whose file contents may be read into memory in parallel while the pool dispatches the current chunk. Worker dispatch itself stays serial. | Repos large enough to chunk (multi-MB total source) where disk I/O is a measurable fraction of analyze wall-clock. | | `GITNEXUS_VERBOSE` | unset | When `1`, enables verbose ingestion logs (skipped-file warnings, per-chunk throughput, parse-cache stats). Equivalent to `--verbose`. | Debugging an analyze that "completed" but seems to have missed files; tuning `--workers` / chunk concurrency against observable throughput. | | `GITNEXUS_PROFILE_DEFERRED` | unset | When `1`, emits `[deferred-profile]` timing/progress logs for the post-chunk deferred resolution band (imports → heritage → buildHeritageMap → legacy call resolution). Implied by `GITNEXUS_VERBOSE`. | Diagnosing analyze stalls in "Resolving calls (all chunks)" on large Java/Kotlin repos (issue #1741) without the full verbose ingestion noise. | diff --git a/gitnexus/bench/parse-throughput.md b/gitnexus/bench/parse-throughput.md index 24a7c98b1..4d53cd2dc 100644 --- a/gitnexus/bench/parse-throughput.md +++ b/gitnexus/bench/parse-throughput.md @@ -70,10 +70,17 @@ this doc, run it under instrumentation: ```bash # From the gitnexus/ subdir: cd gitnexus -# Single-threaded baseline (sequential fallback): -npx vitest run test/integration/parse-impl-large-fixture.test.ts --reporter=verbose +# The worker pool is the sole parse path, so every run needs the dist worker +# (`npm run build`) and a pool size pinned via GITNEXUS_WORKER_POOL_SIZE. -# Worker-pool path (requires built dist/ — pre-built by `npm run build`): +# Single-worker-pool baseline (closest analog to the old single-threaded run — +# sequential parsing was removed, so a 1-worker pool is the floor): +npm run build && \ + GITNEXUS_WORKER_POOL_SIZE=1 \ + GITNEXUS_VERBOSE=1 \ + npx vitest run test/integration/parse-impl-large-fixture.test.ts --reporter=verbose + +# Multi-worker path: npm run build && \ GITNEXUS_WORKER_POOL_SIZE=4 \ GITNEXUS_PARSE_CHUNK_CONCURRENCY=2 \ @@ -97,22 +104,26 @@ node --inspect=0 \ ## Latest measurement > _No measurement data has been collected yet — this file is the -> methodology + harness scaffold. The single recorded data point is the -> U6 wall-clock smoke baseline below; the worker-pool rows are -> placeholders for future bench-pass output._ +> methodology + harness scaffold. The U6 smoke test confirms the +> worker-pool path stays well within its wall-clock budget, but every +> throughput/heap cell below is a `_TBD_` placeholder for a future +> bench-pass._ The U6 integration test (`gitnexus/test/integration/parse-impl-large-fixture.test.ts`) -was observed completing the synthetic fixture in **~6 seconds** under -the sequential path (`skipWorkers: true`) on the development machine, -well under the 30 s `Promise.race` wall-clock budget. That number is a -smoke baseline only — recorded here for reference, not as a regression -target. +runs the worker pool — the sole parse path now that sequential parsing +has been removed (disabling the pool on a repo with parseable files +raises a hard `WorkerPoolDisabledError`). It completes the synthetic +fixture well within the 30 s `Promise.race` wall-clock budget on the +development machine, but no worker-pool throughput/heap numbers have been +captured yet, so the rows below are all `_TBD_`. (An earlier ~6 s figure +recorded here was measured on the now-removed sequential path; it has +been dropped rather than relabelled as a worker-pool baseline, since the +two paths are not comparable.) -| Path | files/s | wall-clock | peak heap | chunks | quarantined | -| ------------------------------------------ | ------- | -------------------- | --------- | ------ | ----------- | -| Sequential (`skipWorkers: true`, U6 smoke) | _TBD_ | ~6 s _(observation)_ | _TBD_ | 17 | 0 | -| Worker pool, `--workers 4`, concurrency 2 | _TBD_ | _TBD_ | _TBD_ | _TBD_ | 0 | -| Worker pool, `--workers 1`, concurrency 1 | _TBD_ | _TBD_ | _TBD_ | _TBD_ | 0 | +| Path | files/s | wall-clock | peak heap | chunks | quarantined | +| ------------------------------------------------------------------------- | ------- | ---------- | --------- | ------ | ----------- | +| Worker pool, `--workers 1` (`GITNEXUS_WORKER_POOL_SIZE=1`), concurrency 1 | _TBD_ | _TBD_ | _TBD_ | _TBD_ | 0 | +| Worker pool, `--workers 4`, concurrency 2 | _TBD_ | _TBD_ | _TBD_ | _TBD_ | 0 | **Hardware:** _TBD — record OS, CPU, RAM, Node version, gitnexus SHA at the time of the bench-pass that populates the table above._ diff --git a/gitnexus/package-lock.json b/gitnexus/package-lock.json index 9ec0598f9..83534ed77 100644 --- a/gitnexus/package-lock.json +++ b/gitnexus/package-lock.json @@ -26,7 +26,6 @@ "ignore": "^7.0.5", "js-yaml": "^4.1.1", "jsonc-parser": "^3.3.1", - "lru-cache": "^11.0.0", "mnemonist": "^0.40.3", "onnxruntime-node": "^1.24.0", "pandemonium": "^2.4.0", diff --git a/gitnexus/package.json b/gitnexus/package.json index 54c0b5d5f..1dbb1ed80 100644 --- a/gitnexus/package.json +++ b/gitnexus/package.json @@ -70,7 +70,6 @@ "ignore": "^7.0.5", "js-yaml": "^4.1.1", "jsonc-parser": "^3.3.1", - "lru-cache": "^11.0.0", "mnemonist": "^0.40.3", "onnxruntime-node": "^1.24.0", "pandemonium": "^2.4.0", diff --git a/gitnexus/src/cli/analyze.ts b/gitnexus/src/cli/analyze.ts index 70bc9a566..3f196b11d 100644 --- a/gitnexus/src/cli/analyze.ts +++ b/gitnexus/src/cli/analyze.ts @@ -60,6 +60,22 @@ const writeFatalToStderr = (label: string, err: unknown): void => { const message = isErr ? err.message : String(err); realStderrWrite(`\n ${label}: ${message}\n`); if (isErr && err.stack) realStderrWrite(`${err.stack}\n`); + // Walk and print the `cause` chain. The phase runner wraps the underlying + // failure as `new Error("Phase 'X' failed: …", { cause })`, so the original + // error (e.g. a WorkerPoolDispatchError carrying the worker-side stack from + // #2068) is only reachable via `.cause`. Without this the user sees the + // wrapper's main-thread stack and never the real frame. `cause.stack` already + // begins with the cause's message, so we print the stack alone (not message + + // stack) to avoid repeating it. Depth-bounded so a cyclic `cause` can't loop + // (the phase runner wraps one level; the bound leaves headroom for future + // nesting); uses realStderrWrite so the redirected console.error's ANSI + // clear-line wrapping can't erase it (#1169). + const MAX_CAUSE_DEPTH = 5; + let cause: unknown = isErr ? (err as { cause?: unknown }).cause : undefined; + for (let depth = 0; depth < MAX_CAUSE_DEPTH && cause instanceof Error; depth++) { + realStderrWrite(`\n Caused by: ${cause.stack ?? cause.message}\n`); + cause = (cause as { cause?: unknown }).cause; + } }; let fatalHandlersInstalled = false; diff --git a/gitnexus/src/core/ingestion/ast-cache.ts b/gitnexus/src/core/ingestion/ast-cache.ts deleted file mode 100644 index 454c60df2..000000000 --- a/gitnexus/src/core/ingestion/ast-cache.ts +++ /dev/null @@ -1,77 +0,0 @@ -import { LRUCache } from 'lru-cache'; -import Parser from 'tree-sitter'; - -import { logger } from '../logger.js'; -/** - * Minimal structural shape consumers need when reading Trees back - * through a phase-dependency boundary. Declared here so phases that - * receive ASTCache via `getPhaseOutput<...>` don't hand-roll their - * own inline structural types that silently drift when ASTCache's - * contract changes. - * - * Typed as `unknown` at the Tree boundary because consumers on the - * other side of the phase-output map don't share tree-sitter's type - * graph (e.g. COBOL's standalone processor). - */ -export interface ASTCacheReader { - get(filePath: string): unknown; - clear(): void; -} - -// Define the interface for the Cache -export interface ASTCache extends ASTCacheReader { - get: (filePath: string) => Parser.Tree | undefined; - set: (filePath: string, tree: Parser.Tree) => void; - clear: () => void; - stats: () => { size: number; maxSize: number }; -} - -export const createASTCache = (maxSize: number = 50): ASTCache => { - const effectiveMax = Math.max(maxSize, 1); - // Initialize the cache with a 'dispose' handler - // This is the magic: When an item is evicted (dropped), this runs automatically. - const cache = new LRUCache({ - max: effectiveMax, - dispose: (tree) => { - try { - // NOTE: web-tree-sitter has tree.delete(); native tree-sitter - // trees are GC-managed and .delete is absent (no-op here). - // - // Single-owner invariant (load-bearing under WASM): a given - // Parser.Tree reference must live in AT MOST ONE ASTCache - // that disposes. The parse-phase chunk-local cache clears - // between chunks; the cross-phase `scopeTreeCache` (also an - // ASTCache today) holds the same Tree by reference. Under - // native tree-sitter this is benign (dispose is a no-op). - // If/when GitNexus adopts web-tree-sitter for sequential - // parsing, the cross-phase cache must either (a) skip - // writing Trees that are already owned by a disposing cache, - // or (b) use tree.copy() per entry. Failing to pick one - // will hand freed memory to scope-resolution. - (tree as unknown as { delete?: () => void }).delete?.(); - } catch (e) { - logger.warn({ e }, 'Failed to delete tree from WASM memory'); - } - }, - }); - - return { - get: (filePath: string) => { - const tree = cache.get(filePath); - return tree; // Returns undefined if not found - }, - - set: (filePath: string, tree: Parser.Tree) => { - cache.set(filePath, tree); - }, - - clear: () => { - cache.clear(); - }, - - stats: () => ({ - size: cache.size, - maxSize: effectiveMax, - }), - }; -}; diff --git a/gitnexus/src/core/ingestion/call-processor.ts b/gitnexus/src/core/ingestion/call-processor.ts index 5c8e447f6..b5b258dcd 100644 --- a/gitnexus/src/core/ingestion/call-processor.ts +++ b/gitnexus/src/core/ingestion/call-processor.ts @@ -9,25 +9,17 @@ * * - `processRoutesFromExtracted` — CALLS edges from framework routes * (e.g. Laravel) to their controller methods. - * - `processNextjsFetchRoutes` / `extractFetchCallsFromFiles` / - * `extractConsumerAccessedKeys` — FETCHES edges from `fetch()` calls to - * Next.js Route nodes. + * - `processNextjsFetchRoutes` / `extractConsumerAccessedKeys` — FETCHES edges + * from `fetch()` calls to Next.js Route nodes. * - `buildExportedTypeMapFromGraph` — exported symbol → return/declared type * map, consumed by the cross-file enrichment pass. */ -import Parser from 'tree-sitter'; import { KnowledgeGraph } from '../graph/types.js'; -import { ASTCache } from './ast-cache.js'; import type { SemanticModel, SymbolTableReader } from './model/index.js'; -import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js'; -import { getProvider } from './languages/index.js'; import { generateId } from '../../lib/utils.js'; -import { getLanguageFromFilename } from 'gitnexus-shared'; import type { SymbolDefinition } from 'gitnexus-shared'; import { yieldToEventLoop } from './utils/event-loop.js'; -import { parseSourceSafe } from '../tree-sitter/safe-parse.js'; -import { getTreeSitterBufferSize } from './constants.js'; import type { ExtractedRoute, ExtractedFetchCall } from './workers/parse-worker.js'; import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js'; import { extractReturnTypeName } from './type-extractors/shared.js'; @@ -454,79 +446,3 @@ export const processNextjsFetchRoutes = ( } } }; - -/** - * Extract fetch() calls from source files (sequential path). - * Workers handle this via tree-sitter captures in parse-worker; this function - * provides the same extraction for the sequential fallback path. - */ -export const extractFetchCallsFromFiles = async ( - files: { path: string; content: string }[], - astCache: ASTCache, -): Promise => { - const parser = await loadParser(); - const result: ExtractedFetchCall[] = []; - - for (const file of files) { - const language = getLanguageFromFilename(file.path); - if (!language) continue; - if (!isLanguageAvailable(language)) continue; - - const provider = getProvider(language); - const queryStr = provider.treeSitterQueries; - if (!queryStr) continue; - - await loadLanguage(language, file.path); - - let tree = astCache.get(file.path); - if (!tree) { - const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content; - try { - tree = parseSourceSafe(parser, parseContent, undefined, { - bufferSize: getTreeSitterBufferSize(parseContent), - }); - } catch { - continue; - } - astCache.set(file.path, tree); - } - - let matches; - try { - const lang = parser.getLanguage(); - const query = new Parser.Query(lang, queryStr); - matches = query.matches(tree.rootNode); - } catch { - continue; - } - - for (const match of matches) { - const captureMap: Record = {}; - match.captures.forEach((c) => (captureMap[c.name] = c.node)); - - if (captureMap['route.fetch']) { - const urlNode = captureMap['route.url'] ?? captureMap['route.template_url']; - if (urlNode) { - result.push({ - filePath: file.path, - fetchURL: urlNode.text, - lineNumber: captureMap['route.fetch'].startPosition.row, - }); - } - } else if (captureMap['http_client'] && captureMap['http_client.url']) { - const method = captureMap['http_client.method']?.text; - const url = captureMap['http_client.url'].text; - const HTTP_CLIENT_ONLY = new Set(['head', 'options', 'request', 'ajax']); - if (method && HTTP_CLIENT_ONLY.has(method) && url.startsWith('/')) { - result.push({ - filePath: file.path, - fetchURL: url, - lineNumber: captureMap['http_client'].startPosition.row, - }); - } - } - } - } - - return result; -}; diff --git a/gitnexus/src/core/ingestion/export-detection.ts b/gitnexus/src/core/ingestion/export-detection.ts index 31d0722f4..17494e7bb 100644 --- a/gitnexus/src/core/ingestion/export-detection.ts +++ b/gitnexus/src/core/ingestion/export-detection.ts @@ -4,7 +4,8 @@ * Determines whether a symbol (function, class, etc.) is exported/public * in its language. This is a pure function — safe for use in worker threads. * - * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback). + * Used by the language providers during worker parsing (parse-worker.ts) — the + * sole parse path. (Sequential parsing was removed.) */ import { findSiblingChild, type SyntaxNode } from './utils/ast-helpers.js'; diff --git a/gitnexus/src/core/ingestion/filesystem-walker.ts b/gitnexus/src/core/ingestion/filesystem-walker.ts index 9ba959ea6..0af28a958 100644 --- a/gitnexus/src/core/ingestion/filesystem-walker.ts +++ b/gitnexus/src/core/ingestion/filesystem-walker.ts @@ -6,10 +6,6 @@ import { glob } from 'glob'; import { createIgnoreFilter } from '../../config/ignore-service.js'; import { logger } from '../logger.js'; -export interface FileEntry { - path: string; - content: string; -} /** Lightweight entry — path + size from stat, no content in memory */ export interface ScannedFile { @@ -153,21 +149,3 @@ export const readFileContents = async ( return contents; }; - -/** - * Legacy API — scans and reads everything into memory. - * Used by sequential fallback path only. - */ -export const walkRepository = async ( - repoPath: string, - onProgress?: (current: number, total: number, filePath: string) => void, -): Promise => { - const scanned = await walkRepositoryPaths(repoPath, onProgress); - const contents = await readFileContents( - repoPath, - scanned.map((f) => f.path), - ); - return scanned - .filter((f) => contents.has(f.path)) - .map((f) => ({ path: f.path, content: contents.get(f.path)! })); -}; diff --git a/gitnexus/src/core/ingestion/languages/python/captures.ts b/gitnexus/src/core/ingestion/languages/python/captures.ts index 761404ebb..756066382 100644 --- a/gitnexus/src/core/ingestion/languages/python/captures.ts +++ b/gitnexus/src/core/ingestion/languages/python/captures.ts @@ -38,9 +38,10 @@ export function emitPythonScopeCaptures( _filePath: string, cachedTree?: unknown, ): readonly CaptureMatch[] { - // Skip the parse when the caller (parse phase's ASTCache) already - // produced a Tree for this source. Cache miss = re-parse, same as - // before. The cachedTree parameter is typed as `unknown` at the + // Skip the parse when the caller (the scope-resolution orchestrator's + // `treeCache`) already produced a Tree for this source — empty under + // worker-pool runs, so cache miss = re-parse. The cachedTree parameter + // is typed as `unknown` at the // contract layer (see `LanguageProvider.emitScopeCaptures`); cast // here at the use site. let tree = cachedTree as ReturnType['parse']> | undefined; diff --git a/gitnexus/src/core/ingestion/pipeline-phases/orm-extraction.ts b/gitnexus/src/core/ingestion/pipeline-phases/orm-extraction.ts deleted file mode 100644 index c6b46610e..000000000 --- a/gitnexus/src/core/ingestion/pipeline-phases/orm-extraction.ts +++ /dev/null @@ -1,106 +0,0 @@ -/** - * Inline ORM query extraction (sequential fallback path). - * - * Extracts Prisma and Supabase query calls from source content using - * regex patterns. Used by the sequential parse path when workers are - * not available — the worker path extracts ORM queries via tree-sitter - * queries instead. - * - * @module - */ - -import type { ExtractedORMQuery } from '../workers/parse-worker.js'; - -// ── Regex patterns ───────────────────────────────────────────────────────── - -/** Matches Prisma client method calls: `prisma.user.findMany(...)` */ -const PRISMA_QUERY_RE = - /\bprisma\.(\w+)\.(findMany|findFirst|findUnique|findUniqueOrThrow|findFirstOrThrow|create|createMany|update|updateMany|delete|deleteMany|upsert|count|aggregate|groupBy)\s*\(/g; - -/** Matches Supabase client method calls: `supabase.from('users').select(...)` */ -const SUPABASE_QUERY_RE = - /\bsupabase\.from\s*\(\s*['"](\w+)['"]\s*\)\s*\.(select|insert|update|delete|upsert)\s*\(/g; - -// ── Extraction function ─────────────────────────────────────────────────── - -/** - * Extract ORM query calls from file content using regex. - * - * Fast-path: skips files that don't contain `prisma.` or `supabase.from`. - * Results are appended to the `out` array (push pattern avoids allocation). - * - * @param filePath Relative path of the source file - * @param content File content string - * @param out Output array to append extracted queries to - */ -export function extractORMQueriesInline( - filePath: string, - content: string, - out: ExtractedORMQuery[], -): void { - const hasPrisma = content.includes('prisma.'); - const hasSupabase = content.includes('supabase.from'); - if (!hasPrisma && !hasSupabase) return; - - // Pre-compute line number offsets to avoid O(n²) substring+split per match - const lineOffsets = buildLineOffsets(content); - - if (hasPrisma) { - PRISMA_QUERY_RE.lastIndex = 0; - let m; - while ((m = PRISMA_QUERY_RE.exec(content)) !== null) { - const model = m[1]; - if (model.startsWith('$')) continue; - out.push({ - filePath, - orm: 'prisma', - model, - method: m[2], - lineNumber: lineNumberAtOffset(lineOffsets, m.index), - }); - } - } - - if (hasSupabase) { - SUPABASE_QUERY_RE.lastIndex = 0; - let m; - while ((m = SUPABASE_QUERY_RE.exec(content)) !== null) { - out.push({ - filePath, - orm: 'supabase', - model: m[1], - method: m[2], - lineNumber: lineNumberAtOffset(lineOffsets, m.index), - }); - } - } -} - -// ── Line offset helpers ─────────────────────────────────────────────────── - -/** Build an array of byte offsets where each newline occurs (O(n) once). */ -function buildLineOffsets(content: string): number[] { - const offsets: number[] = []; - for (let i = 0; i < content.length; i++) { - if (content[i] === '\n') offsets.push(i); - } - return offsets; -} - -/** - * Binary search for 0-based line number at a given character offset. - * - * Returns the number of newlines that occur before `offset` in the content, - * which is the 0-based line number. When `offset` is beyond the last newline, - * returns `lineOffsets.length` (i.e., the last line index). - */ -function lineNumberAtOffset(lineOffsets: number[], offset: number): number { - let lo = 0; - let hi = lineOffsets.length; - while (lo < hi) { - const mid = (lo + hi) >>> 1; - if (lineOffsets[mid] < offset) lo = mid + 1; - else hi = mid; - } - return lo; -} diff --git a/gitnexus/src/core/ingestion/pipeline-phases/parse-impl.ts b/gitnexus/src/core/ingestion/pipeline-phases/parse-impl.ts index 86bb5e587..244f178dd 100644 --- a/gitnexus/src/core/ingestion/pipeline-phases/parse-impl.ts +++ b/gitnexus/src/core/ingestion/pipeline-phases/parse-impl.ts @@ -43,7 +43,6 @@ import { type ExportedTypeMap, } from '../call-processor.js'; import { createSemanticModel, type MutableSemanticModel } from '../model/index.js'; -import { createASTCache } from '../ast-cache.js'; import { type PipelineProgress, getLanguageFromFilename } from 'gitnexus-shared'; import { readFileContents } from '../filesystem-walker.js'; import { isLanguageAvailable } from '../../tree-sitter/parser-loader.js'; @@ -466,14 +465,6 @@ export async function runChunkedParseAndResolve( let filesParsedSoFar = 0; - // Chunk-local tree-sitter cache, cleared between chunks — call / heritage / - // import processors read it during parse to avoid re-parsing within the same - // chunk. (The former cross-phase `scopeTreeCache` was only ever populated by - // the sequential parser, which has been removed; workers can't return native - // Trees across the MessageChannel, so scope-resolution re-parses as needed.) - const maxChunkFiles = chunks.reduce((max, c) => Math.max(max, c.length), 0); - const astCache = createASTCache(maxChunkFiles); - const exportedTypeMap: ExportedTypeMap = new Map(); const bindingAccumulator = new BindingAccumulator(); const allFetchCalls: ExtractedFetchCall[] = []; @@ -649,7 +640,6 @@ export async function runChunkedParseAndResolve( } filesParsedSoFar += chunkFiles.length; - astCache.clear(); if (verboseThroughputLog && chunkStartMs !== null) { const elapsedMs = Date.now() - chunkStartMs; @@ -943,7 +933,6 @@ export async function runChunkedParseAndResolve( // Finalize the accumulator and propagate any fixpoint-inferred exports before // `crossFile` disposes it downstream. Wrapped in try/catch so a cleanup // failure never masks a real parse error; disposal stays with `crossFile`. - astCache.clear(); try { bindingAccumulator.finalize(); const enriched = enrichExportedTypeMap(bindingAccumulator, graph, exportedTypeMap); diff --git a/gitnexus/src/core/ingestion/workers/parse-worker.ts b/gitnexus/src/core/ingestion/workers/parse-worker.ts index c5763a66d..9a3837494 100644 --- a/gitnexus/src/core/ingestion/workers/parse-worker.ts +++ b/gitnexus/src/core/ingestion/workers/parse-worker.ts @@ -2434,7 +2434,21 @@ parentPort!.on('message', (msg: WorkerIncomingMessage) => { return; } } catch (err) { - const message = err instanceof Error ? err.message : String(err); - parentPort!.postMessage({ type: 'error', error: message }); + // Carry the worker-side stack across the MessageChannel, not just the + // message. Without this, an unexpected worker throw (e.g. the minified + // `this.# is not a function` family) reaches the operator as a bare + // one-liner with no file:line — exactly what made #2068 undebuggable. The + // pool embeds `errorStack` into its death/circuit-breaker reason so the + // surfaced "Phase 'parse' failed" message points at the real frame (the + // stack's first line already carries the error's type + message). We send + // primitive fields (not the raw Error) so a non-cloneable `cause` payload + // can never turn the report itself into a `messageerror`. `errorStack` is + // optional on the wire, so an older pool ignores it. + const e = err instanceof Error ? err : new Error(String(err)); + parentPort!.postMessage({ + type: 'error', + error: e.message, + errorStack: e.stack, + }); } }); diff --git a/gitnexus/src/core/ingestion/workers/worker-pool.ts b/gitnexus/src/core/ingestion/workers/worker-pool.ts index 93fb6863d..5082453a0 100644 --- a/gitnexus/src/core/ingestion/workers/worker-pool.ts +++ b/gitnexus/src/core/ingestion/workers/worker-pool.ts @@ -310,7 +310,15 @@ type WorkerOutgoingMessage = | { type: 'progress'; filesProcessed: number } | { type: 'warning'; message: string } | { type: 'sub-batch-done' } - | { type: 'error'; error: string } + /** + * Worker-side caught error. `error` is the message; `errorStack` carries the + * worker thread's stack so the pool can embed a real file:line into its + * death / circuit-breaker reason instead of surfacing a bare one-liner (the + * #2068 diagnosability gap). `errorStack` is optional so an older worker + * build that only sends `error` still validates and degrades to message-only + * — and a newer pool reading it just gets no stack. + */ + | { type: 'error'; error: string; errorStack?: string } | { type: 'result'; data: unknown } /** * Authoritative in-flight signal: worker is about to process this file. @@ -656,6 +664,25 @@ function withStderr(worker: Worker, message: string): string { return tail ? `${message}. Worker stderr:\n${tail}` : message; } +/** + * Build a worker-death reason string that carries the worker-side stack when one + * is available (#2068). The stack is appended AFTER the `Worker N error: ` + * prefix so every prefix/substring consumer downstream — recoverAndResume → + * handleWorkerDeath → the circuit-breaker `WorkerPoolDispatchError` message, and + * the tests that regex-match those — keeps working unchanged, while the operator + * now gets the real frame instead of a bare one-liner. The stack's first line is + * normally the message itself; keeping both is harmless and the indented block + * scans cleanly in a log. The stack is capped at WORKER_STDERR_TAIL_LIMIT, + * mirroring the sibling stderr-tail bound, so a pathological error type (or a + * raised `Error.stackTraceLimit`) can't bloat the death reason. `stack` is + * `undefined` for an older worker build (or a thrown non-Error), in which case + * the reason is exactly the prior message-only form. + */ +function workerErrorReason(workerIndex: number, message: string, stack?: string): string { + const base = `Worker ${workerIndex} error: ${message}`; + return stack ? `${base}\n worker stack:\n${stack.slice(0, WORKER_STDERR_TAIL_LIMIT)}` : base; +} + /** * Wait for a freshly-spawned replacement worker to emit the * `{type:'ready'}` handshake from `parse-worker.ts` before treating its @@ -1832,7 +1859,7 @@ export const createWorkerPool = ( settled = true; cleanup(); void recoverAndResume( - `Worker ${workerIndex} error: ${msg.error}`, + workerErrorReason(workerIndex, msg.error, msg.errorStack), resolveExcludePaths(), ); } else if (msg.type === 'result') { @@ -1877,8 +1904,13 @@ export const createWorkerPool = ( if (!settled) { settled = true; cleanup(); + // The Node 'error' event fires on an UNCAUGHT worker throw (one that + // escaped the worker's own try/catch, or an async rejection). Unlike + // the `{type:'error'}` message, the event delivers a real Error whose + // `.stack` is the worker-side frame — carry it so the surfaced reason + // points at the actual failure site, not just `err.message` (#2068). void recoverAndResume( - `Worker ${workerIndex} error: ${err.message}`, + workerErrorReason(workerIndex, err.message, err.stack), resolveExcludePaths(), ); } diff --git a/gitnexus/src/core/lbug/lbug-adapter.ts b/gitnexus/src/core/lbug/lbug-adapter.ts index a41a9d201..51f5ce860 100644 --- a/gitnexus/src/core/lbug/lbug-adapter.ts +++ b/gitnexus/src/core/lbug/lbug-adapter.ts @@ -7,6 +7,7 @@ import path from 'path'; import os from 'os'; import crypto from 'crypto'; import lbug from '@ladybugdb/core'; +import { closeQueryResults } from './query-result-utils.js'; import { KnowledgeGraph } from '../graph/types.js'; import { NODE_TABLES, @@ -213,8 +214,18 @@ const DB_LOCK_RETRY_DELAY_MS = 500; * analyze` and either already happened or will happen on the next run. */ export const isReadOnlyDbError = (err: unknown): boolean => { - const msg = err instanceof Error ? err.message : String(err); - return /read-only database/i.test(msg); + // Walk the `cause` chain (bounded) so a wrapped read-only error — e.g. the + // pool adapter's `new Error('…read-only.', { cause: nativeReadOnlyErr })` — + // is still detected by callers that only see the wrapper (#2068 follow-up). + // The same strict regex is re-applied at each level, so a non-read-only + // chain stays false; the depth bound guards a cyclic `cause`. + let cur: unknown = err; + for (let depth = 0; depth < 5 && cur != null; depth++) { + const msg = cur instanceof Error ? cur.message : String(cur); + if (/read-only database/i.test(msg)) return true; + cur = cur instanceof Error ? (cur as { cause?: unknown }).cause : undefined; + } + return false; }; const isMissingFileError = (err: unknown): boolean => { @@ -392,12 +403,10 @@ const runWithSessionLock = async (operation: () => Promise): Promise => const normalizeCopyPath = (filePath: string): string => toNativeSafePath(filePath).replace(/\\/g, '/'); +// Single-result convenience wrapper over the shared best-effort closer +// (drainQueryResult / readQueryRows close one cursor at a time). const closeQueryResult = async (result: lbug.QueryResult): Promise => { - try { - await result.close(); - } catch { - // Best-effort cleanup only. - } + await closeQueryResults(result); }; const drainQueryResult = async ( @@ -1758,8 +1767,9 @@ export const queryImporters = async (targetFilePath: string): Promise WHERE r.type = 'IMPORTS' AND b.filePath = '${escaped}' RETURN DISTINCT a.filePath AS importer `; + let queryResult: lbug.QueryResult | lbug.QueryResult[] | undefined; try { - const queryResult = await conn.query(cypher); + queryResult = await conn.query(cypher); const result = Array.isArray(queryResult) ? queryResult[0] : queryResult; const rows = await result.getAll(); const out: string[] = []; @@ -1770,6 +1780,8 @@ export const queryImporters = async (targetFilePath: string): Promise return out; } catch { return []; + } finally { + if (queryResult) await closeQueryResults(queryResult); } }; @@ -1788,8 +1800,9 @@ export const deleteAllCommunitiesAndProcesses = async (): Promise<{ } let nodesDeleted = 0; for (const label of ['Community', 'Process']) { + let countResult: lbug.QueryResult | lbug.QueryResult[] | undefined; try { - const countResult = await conn.query(`MATCH (n:${label}) RETURN count(n) AS cnt`); + countResult = await conn.query(`MATCH (n:${label}) RETURN count(n) AS cnt`); const result = Array.isArray(countResult) ? countResult[0] : countResult; const rows = await result.getAll(); const count = Number(rows[0]?.cnt ?? rows[0]?.[0] ?? 0); @@ -1799,6 +1812,8 @@ export const deleteAllCommunitiesAndProcesses = async (): Promise<{ } } catch { // Table may not exist yet on a freshly-initialized DB — fine. + } finally { + if (countResult) await closeQueryResults(countResult); } } return { nodesDeleted }; diff --git a/gitnexus/src/core/lbug/pool-adapter.ts b/gitnexus/src/core/lbug/pool-adapter.ts index 1b868d8c1..030688d14 100644 --- a/gitnexus/src/core/lbug/pool-adapter.ts +++ b/gitnexus/src/core/lbug/pool-adapter.ts @@ -18,6 +18,7 @@ import fs from 'fs/promises'; import lbug from '@ladybugdb/core'; import { isReadOnlyDbError, loadFTSExtension } from './lbug-adapter.js'; +import { closeQueryResults } from './query-result-utils.js'; import { createLbugDatabase, isWalCorruptionError, @@ -41,8 +42,14 @@ interface PoolEntry { available: lbug.Connection[]; /** Number of connections currently checked out */ checkedOut: number; - /** Queued waiters for when all connections are busy */ - waiters: Array<(conn: lbug.Connection) => void>; + /** Queued waiters for when all connections are busy. Each carries `resolve` + * (hand off a freed connection) and `reject` (fail fast when the pool is + * closed before a connection frees, instead of hanging until the waiter + * timeout — #2068 follow-up). */ + waiters: Array<{ + resolve: (conn: lbug.Connection) => void; + reject: (err: Error) => void; + }>; lastUsed: number; dbPath: string; /** Set to true when the pool entry is closed — checkin will close orphaned connections */ @@ -176,6 +183,20 @@ function closeOne(repoId: string): void { entry.closed = true; + // Reject any callers still queued for a connection: the pool is going away + // (re-init / teardown / LRU eviction), so they must fail fast with an + // actionable error instead of hanging until WAITER_TIMEOUT_MS and then + // surfacing a misleading "pool exhausted" (#2068 follow-up). Draining the + // queue also guarantees checkin() below finds no waiter expecting a + // connection, so a connection returned after close is simply closed. + if (entry.waiters.length > 0) { + const closedErr = new Error( + `LadybugDB connection pool closed for repo "${repoId}" (re-init/teardown); retry the query.`, + ); + for (const waiter of entry.waiters) waiter.reject(closedErr); + entry.waiters.length = 0; + } + // Close available connections — fire-and-forget with .catch() to prevent // unhandled rejections. Native close() returns Promise but can crash // the N-API destructor on macOS/Windows; deferring to process exit lets @@ -680,14 +701,20 @@ function checkout(entry: PoolEntry): Promise { // At capacity — queue the caller with a timeout. return new Promise((resolve, reject) => { - const waiter = (conn: lbug.Connection) => { - clearTimeout(timer); - resolve(conn); + const waiter = { + resolve: (conn: lbug.Connection) => { + clearTimeout(timer); + resolve(conn); + }, + reject: (err: Error) => { + clearTimeout(timer); + reject(err); + }, }; const timer = setTimeout(() => { const idx = entry.waiters.indexOf(waiter); if (idx !== -1) entry.waiters.splice(idx, 1); - reject( + waiter.reject( new Error( `Connection pool exhausted: timed out after ${WAITER_TIMEOUT_MS}ms waiting for a free connection`, ), @@ -713,7 +740,7 @@ function checkin(entry: PoolEntry, conn: lbug.Connection): void { if (entry.waiters.length > 0) { // Hand directly to the next waiter — no intermediate available state const waiter = entry.waiters.shift()!; - waiter(conn); + waiter.resolve(conn); } else { entry.checkedOut--; entry.available.push(conn); @@ -756,22 +783,33 @@ export const executeParameterized = async ( const conn = await checkout(entry); silenceStdout(); activeQueryCount++; + let queryResult: lbug.QueryResult | lbug.QueryResult[] | undefined; try { const stmt = await withTimeout(conn.prepare(cypher), QUERY_TIMEOUT_MS, 'Prepare'); if (!stmt.isSuccess()) { const errMsg = await stmt.getErrorMessage(); throw new Error(`Prepare failed: ${errMsg}`); } - const queryResult = await withTimeout(conn.execute(stmt, params), QUERY_TIMEOUT_MS, 'Execute'); + queryResult = await withTimeout(conn.execute(stmt, params), QUERY_TIMEOUT_MS, 'Execute'); const result = Array.isArray(queryResult) ? queryResult[0] : queryResult; const rows = await result.getAll(); return rows; } catch (err) { if (isReadOnlyDbError(err)) { - throw new Error('Write operations are not allowed. The pool adapter is read-only.'); + // Preserve the native error as `cause` so the original frame/message is + // not lost behind the friendly read-only message (#2068 follow-up). + throw new Error('Write operations are not allowed. The pool adapter is read-only.', { + cause: err, + }); } throw err; } finally { + // Close the native QueryResult cursor(s) before returning the connection — + // getAll() drains rows but does not release the native cursor, so without + // this the cursor leaks for the connection's lifetime (#2068 follow-up). + // Best-effort via the shared helper; never masks the query result or a real + // error. + if (queryResult) await closeQueryResults(queryResult); activeQueryCount--; restoreStdout(); checkin(entry, conn); diff --git a/gitnexus/src/core/lbug/query-result-utils.ts b/gitnexus/src/core/lbug/query-result-utils.ts new file mode 100644 index 000000000..938e28a2b --- /dev/null +++ b/gitnexus/src/core/lbug/query-result-utils.ts @@ -0,0 +1,31 @@ +import lbug from '@ladybugdb/core'; + +/** + * Best-effort close of one or more native `QueryResult` cursors. + * + * `result.getAll()` materializes rows into a JS array but does not release the + * native cursor — leaving it open holds native resources for the connection's + * lifetime. Both the pooled adapter (`pool-adapter.ts`) and the direct adapter + * (`lbug-adapter.ts`) must release cursors after reading; this is the single + * shared implementation so neither re-rolls the array-normalize + swallow loop + * (a #2068 follow-up de-dup). Lives in its own leaf module so the two adapters + * depend on it rather than on each other. + * + * `conn.execute()` can return either a single `QueryResult` or an array + * (multi-statement); this normalizes both. Each close is independent and + * best-effort: a failing or absent `close()` on one cursor never throws and + * never prevents the others from closing — a cleanup failure must not mask the + * query result or a real error at the call site. + */ +export async function closeQueryResults( + queryResult: lbug.QueryResult | lbug.QueryResult[], +): Promise { + const results = Array.isArray(queryResult) ? queryResult : [queryResult]; + for (const r of results) { + try { + await r?.close(); + } catch { + // Best-effort cleanup only. + } + } +} diff --git a/gitnexus/src/mcp/local/local-backend.ts b/gitnexus/src/mcp/local/local-backend.ts index 46ecf4030..77411b107 100644 --- a/gitnexus/src/mcp/local/local-backend.ts +++ b/gitnexus/src/mcp/local/local-backend.ts @@ -177,8 +177,19 @@ function logQueryError(context: string, err: unknown): void { logger.error({ context, err: msg }, 'GitNexus query failed'); } -const isReadOnlyDbError = (err: unknown): boolean => - /read-only database/i.test(err instanceof Error ? err.message : String(err)); +const isReadOnlyDbError = (err: unknown): boolean => { + // Walk the `cause` chain (bounded) so a wrapped read-only error (e.g. the + // pool adapter's `{ cause }` wrapper) is still detected here — this is the + // copy the MCP cypher handler uses to surface its curated read-only message + // (#2068 follow-up). Mirrors lbug-adapter's isReadOnlyDbError. + let cur: unknown = err; + for (let depth = 0; depth < 5 && cur != null; depth++) { + const msg = cur instanceof Error ? cur.message : String(cur); + if (/read-only database/i.test(msg)) return true; + cur = cur instanceof Error ? (cur as { cause?: unknown }).cause : undefined; + } + return false; +}; /** * Per-query latency telemetry for production aggregation (#553). diff --git a/gitnexus/src/types/pipeline.ts b/gitnexus/src/types/pipeline.ts index becf81757..5ad08cae6 100644 --- a/gitnexus/src/types/pipeline.ts +++ b/gitnexus/src/types/pipeline.ts @@ -19,9 +19,12 @@ export interface PipelineResult { */ resolutionOutcomes: readonly ResolutionOutcome[]; /** - * True if the parse phase spawned a worker pool for this run. False means - * the sequential fallback handled every chunk. Primarily a test affordance - * so regression suites can prove which path executed. + * True if a worker pool was actually constructed for this run. The worker + * pool is the sole parse path (sequential parsing was removed). False means + * no pool was needed: either there were no parseable files, or every chunk + * was a parse-cache hit and the cached worker output was replayed without + * spawning workers (a warm all-cache-hit run, #2038). Primarily a test + * affordance so regression suites can prove the pool engaged. */ usedWorkerPool: boolean; } diff --git a/gitnexus/test/integration/lbug-pool.test.ts b/gitnexus/test/integration/lbug-pool.test.ts index 259c15c13..561772a75 100644 --- a/gitnexus/test/integration/lbug-pool.test.ts +++ b/gitnexus/test/integration/lbug-pool.test.ts @@ -94,6 +94,86 @@ withTestLbugDB( }); }); + // ─── closeLbug rejects pending waiters (#2068 follow-up) ───────────── + // + // Before the fix, closeOne() never rejected queued waiters: a caller + // waiting for a free connection when the pool was closed (e.g. a staleness + // reinit under concurrent query load) hung for WAITER_TIMEOUT_MS (15s) and + // then surfaced a misleading "pool exhausted" error. Now they reject + // immediately with an actionable "pool closed" message. The pool caps at + // MAX_CONNS_PER_REPO (8); firing a synchronous burst larger than that queues + // the surplus as waiters, and closing synchronously (before any query + // settles) must reject every queued waiter at once. The default 5s test + // timeout also guards promptness — a regression would block ~15s and time + // out rather than reject. + describe('closeLbug waiter handling (#2068)', () => { + it('rejects queued waiters promptly with a pool-closed error on close', async () => { + await initLbug('test-repo', handle.dbPath); + + // Fire a burst larger than the 8-connection cap WITHOUT awaiting: the + // first 8 check out connections synchronously, the surplus queue as + // waiters — all before the synchronous closeLbug below runs. + const BURST = 24; + const MAX_CONNS = 8; + const inflight = Array.from({ length: BURST }, () => + executeQuery('test-repo', 'MATCH (n:Function) RETURN n.name AS name'), + ); + // Close in the same synchronous tick — no microtask has served a waiter. + const closing = closeLbug('test-repo'); + + const settled = await Promise.allSettled(inflight); + await closing; + + const reasons = settled + .filter((r): r is PromiseRejectedResult => r.status === 'rejected') + .map((r) => String(r.reason?.message ?? r.reason)); + + // The surplus (BURST - MAX_CONNS) waiters must reject with "pool closed". + const poolClosed = reasons.filter((m) => /pool closed/i.test(m)); + expect(poolClosed.length).toBeGreaterThanOrEqual(BURST - MAX_CONNS); + // And none should have hit the 15s "exhausted" waiter-timeout path. + expect(reasons.some((m) => /waiting for a free connection/i.test(m))).toBe(false); + + expect(isLbugReady('test-repo')).toBe(false); + }); + + it('settles in-flight queries and fully tears down when closed mid-flight', async () => { + // closeOne-vs-checkin interleave (F4b): with 8 connections in-flight and + // surplus callers queued, a synchronous close must (a) let every promise + // settle — no hang — and (b) fully delete the pool entry so checked-in + // connections are closed as orphans rather than handed to a rejected + // waiter. We assert the observable contract; the "orphan not handed to a + // rejected waiter" invariant is single-threaded-by-construction (closeOne + // drains waiters with no await before any checkin can run). + await initLbug('test-repo', handle.dbPath); + + const inflight = Array.from({ length: 16 }, () => + executeQuery('test-repo', 'MATCH (n:Function) RETURN n.name AS name'), + ); + const closing = closeLbug('test-repo'); + + // allSettled only resolves once EVERY query settled — proving none hangs + // (a 15s waiter-timeout regression would blow the default test timeout). + const settled = await Promise.allSettled(inflight); + await closing; + expect(settled).toHaveLength(16); + expect( + settled.some( + (r) => + r.status === 'rejected' && + /waiting for a free connection/i.test(String(r.reason?.message ?? r.reason)), + ), + ).toBe(false); + + // Pool entry fully gone — a subsequent query fails fast with the + // not-initialized error, not a hang or a stale connection. + expect(isLbugReady('test-repo')).toBe(false); + await expect(executeQuery('test-repo', 'MATCH (n) RETURN n LIMIT 1')).rejects.toThrow( + /not initialized/i, + ); + }); + }); + // ─── Parameterized queries ─────────────────────────────────────────── describe('executeParameterized', () => { diff --git a/gitnexus/test/unit/ast-cache.test.ts b/gitnexus/test/unit/ast-cache.test.ts deleted file mode 100644 index 66cc6e3c3..000000000 --- a/gitnexus/test/unit/ast-cache.test.ts +++ /dev/null @@ -1,95 +0,0 @@ -import { describe, it, expect, beforeEach } from 'vitest'; -import { createASTCache, type ASTCache } from '../../src/core/ingestion/ast-cache.js'; - -// Create a minimal mock tree object (mimics Parser.Tree interface) -function mockTree(id: string): any { - return { rootNode: { type: 'program', text: id }, delete: vi.fn() }; -} - -describe('ASTCache', () => { - let cache: ASTCache; - - beforeEach(() => { - cache = createASTCache(3); - }); - - describe('get / set', () => { - it('returns undefined for cache miss', () => { - expect(cache.get('nonexistent.ts')).toBeUndefined(); - }); - - it('returns cached tree on hit', () => { - const tree = mockTree('test'); - cache.set('src/index.ts', tree); - expect(cache.get('src/index.ts')).toBe(tree); - }); - - it('overwrites existing entry for same key', () => { - const tree1 = mockTree('v1'); - const tree2 = mockTree('v2'); - cache.set('src/index.ts', tree1); - cache.set('src/index.ts', tree2); - expect(cache.get('src/index.ts')).toBe(tree2); - }); - }); - - describe('LRU eviction', () => { - it('evicts least recently used when capacity exceeded', () => { - cache.set('a.ts', mockTree('a')); - cache.set('b.ts', mockTree('b')); - cache.set('c.ts', mockTree('c')); - // Cache is full (maxSize=3). Adding one more evicts 'a' - cache.set('d.ts', mockTree('d')); - expect(cache.get('a.ts')).toBeUndefined(); - expect(cache.get('b.ts')).toBeDefined(); - expect(cache.get('d.ts')).toBeDefined(); - }); - - it('accessing an entry makes it recently used', () => { - cache.set('a.ts', mockTree('a')); - cache.set('b.ts', mockTree('b')); - cache.set('c.ts', mockTree('c')); - // Touch 'a' to make it recently used - cache.get('a.ts'); - // Now 'b' is LRU - cache.set('d.ts', mockTree('d')); - expect(cache.get('a.ts')).toBeDefined(); - expect(cache.get('b.ts')).toBeUndefined(); - }); - }); - - describe('clear', () => { - it('removes all entries', () => { - cache.set('a.ts', mockTree('a')); - cache.set('b.ts', mockTree('b')); - cache.clear(); - expect(cache.get('a.ts')).toBeUndefined(); - expect(cache.get('b.ts')).toBeUndefined(); - expect(cache.stats().size).toBe(0); - }); - }); - - describe('stats', () => { - it('reports size and maxSize', () => { - expect(cache.stats()).toEqual({ size: 0, maxSize: 3 }); - cache.set('a.ts', mockTree('a')); - expect(cache.stats()).toEqual({ size: 1, maxSize: 3 }); - cache.set('b.ts', mockTree('b')); - expect(cache.stats()).toEqual({ size: 2, maxSize: 3 }); - }); - - it('uses default maxSize of 50', () => { - const defaultCache = createASTCache(); - expect(defaultCache.stats().maxSize).toBe(50); - }); - - it('clamps maxSize of 0 to 1 to prevent LRU cache error', () => { - const zeroCache = createASTCache(0); - expect(zeroCache.stats().maxSize).toBe(1); - // Should still function correctly - const tree = mockTree('test'); - zeroCache.set('a.ts', tree); - expect(zeroCache.get('a.ts')).toBe(tree); - }); - }); -}); diff --git a/gitnexus/test/unit/lbug-query-result-utils.test.ts b/gitnexus/test/unit/lbug-query-result-utils.test.ts new file mode 100644 index 000000000..9a7ac3ad8 --- /dev/null +++ b/gitnexus/test/unit/lbug-query-result-utils.test.ts @@ -0,0 +1,45 @@ +/** + * Unit tests: closeQueryResults — the shared best-effort cursor-close helper + * (#2068 follow-up). Guards the contract the two LadybugDB adapters rely on: + * a single result OR an array of results are all closed, and a failing/absent + * `close()` never throws and never skips the rest. + */ +import { describe, it, expect, vi } from 'vitest'; +import { closeQueryResults } from '../../src/core/lbug/query-result-utils.js'; + +// Minimal QueryResult stand-in — only `close()` matters here. +function fakeResult(close: () => unknown = () => undefined) { + return { close: vi.fn(close) } as unknown as import('@ladybugdb/core').QueryResult; +} + +describe('closeQueryResults', () => { + it('closes a single QueryResult exactly once', async () => { + const r = fakeResult(); + await closeQueryResults(r); + expect(r.close as ReturnType).toHaveBeenCalledTimes(1); + }); + + it('closes EVERY element of an array (not just the first)', async () => { + const rs = [fakeResult(), fakeResult(), fakeResult()]; + await closeQueryResults(rs); + for (const r of rs) { + expect(r.close as ReturnType).toHaveBeenCalledTimes(1); + } + }); + + it('keeps closing the rest when one close() rejects (best-effort, no throw)', async () => { + const ok1 = fakeResult(); + const bad = fakeResult(() => { + throw new Error('native close failed'); + }); + const ok2 = fakeResult(() => Promise.reject(new Error('async close failed'))); + const ok3 = fakeResult(); + await expect(closeQueryResults([ok1, bad, ok2, ok3])).resolves.toBeUndefined(); + expect(ok1.close as ReturnType).toHaveBeenCalledTimes(1); + expect(ok3.close as ReturnType).toHaveBeenCalledTimes(1); + }); + + it('is a no-op on an empty array', async () => { + await expect(closeQueryResults([])).resolves.toBeUndefined(); + }); +}); diff --git a/gitnexus/test/unit/lbug-readonly-error.test.ts b/gitnexus/test/unit/lbug-readonly-error.test.ts index 4e412c323..514ddc07d 100644 --- a/gitnexus/test/unit/lbug-readonly-error.test.ts +++ b/gitnexus/test/unit/lbug-readonly-error.test.ts @@ -41,6 +41,34 @@ describe('isReadOnlyDbError', () => { expect(isReadOnlyDbError(undefined)).toBe(false); }); + it('detects a read-only error wrapped as a `cause` (#2068 — pool-adapter wrapper)', () => { + // The pool adapter rethrows native read-only failures as a friendly + // message with the original error preserved on `cause`. Detection must see + // through the wrapper so the MCP/HTTP handlers surface their curated message. + const wrapped = new Error('Write operations are not allowed. The pool adapter is read-only.', { + cause: new Error('Cannot execute write operations in a read-only database!'), + }); + expect(isReadOnlyDbError(wrapped)).toBe(true); + }); + + it('does NOT match a wrapper whose cause chain is unrelated', () => { + const wrapped = new Error('Query failed', { cause: new Error('Connection refused') }); + expect(isReadOnlyDbError(wrapped)).toBe(false); + }); + + it('terminates on a cyclic cause chain without hanging', () => { + const a = new Error('boom a') as Error & { cause?: unknown }; + const b = new Error('boom b') as Error & { cause?: unknown }; + a.cause = b; + b.cause = a; + expect(isReadOnlyDbError(a)).toBe(false); + }); + + it('stops cleanly on a non-Error cause', () => { + const wrapped = new Error('outer', { cause: 'just a string' }); + expect(isReadOnlyDbError(wrapped)).toBe(false); + }); + it('does NOT match unrelated errors that the ensure path must still surface', () => { // Lock contention — handled separately by isDbBusyError; must not be // silenced by the read-only filter. diff --git a/gitnexus/test/unit/worker-pool-error-stack.test.ts b/gitnexus/test/unit/worker-pool-error-stack.test.ts new file mode 100644 index 000000000..fbd828142 --- /dev/null +++ b/gitnexus/test/unit/worker-pool-error-stack.test.ts @@ -0,0 +1,176 @@ +import { describe, expect, it, beforeEach, afterEach } from 'vitest'; +import { EventEmitter } from 'node:events'; +import path from 'node:path'; +import { pathToFileURL } from 'node:url'; +import fs from 'node:fs'; +import os from 'node:os'; + +import { + createWorkerPool, + WorkerPoolDispatchError, +} from '../../src/core/ingestion/workers/worker-pool.js'; + +/** + * #2068 regression: a worker-side crash must carry its stack across the + * MessageChannel so the surfaced "Phase 'parse' failed" error points at a real + * frame instead of a bare one-liner (the issue's `this.#q is not a function` + * reached the operator with no file:line because the worker only sent + * `err.message`). These tests assert the worker stack rides through both worker + * failure channels — the `{type:'error'}` message (a caught worker throw) and + * the Node `'error'` event (an uncaught worker throw) — into the + * `WorkerPoolDispatchError` the parse phase rejects with, and that an older + * worker build that omits the stack still degrades cleanly. + */ + +type NodeWorker = import('node:worker_threads').Worker; + +type FakeAction = + | { kind: 'error-message'; error: string; errorStack?: string } + | { kind: 'error-event'; message: string; stack: string }; + +const nextActions: FakeAction[] = []; + +/** + * Minimal worker double: emits the readiness handshake on construction, then + * runs one scripted action per dispatched sub-batch. Unlike the resilience + * suite's double, this one can emit the `{type:'error', errorStack}` MESSAGE + * (the worker's own caught-error path) in addition to the Node `'error'` event. + */ +class FakeWorker extends EventEmitter { + constructor() { + super(); + queueMicrotask(() => { + this.emit('online'); + this.emit('message', { type: 'ready' }); + }); + } + + postMessage(rawMsg: unknown): void { + const m = rawMsg as { type?: string }; + // Only a real dispatch drives an action; ignore the pool's `flush` reply. + if (!m || m.type !== 'sub-batch') return; + const action = nextActions.shift(); + if (!action) return; + queueMicrotask(() => { + if (action.kind === 'error-message') { + this.emit('message', { + type: 'error', + error: action.error, + errorStack: action.errorStack, + }); + } else { + const e = new Error(action.message); + e.stack = action.stack; + this.emit('error', e); + } + }); + } + + async terminate(): Promise { + this.emit('exit', 0); + return 0; + } +} + +let tempDir: string; +let workerUrl: URL; + +beforeEach(() => { + nextActions.length = 0; + tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitnexus-worker-error-stack-')); + const workerPath = path.join(tempDir, 'fake-worker.js'); + fs.writeFileSync(workerPath, '// fake'); + workerUrl = pathToFileURL(workerPath) as URL; +}); + +afterEach(() => { + try { + fs.rmSync(tempDir, { recursive: true, force: true }); + } catch { + // best-effort cleanup + } +}); + +// Trip the breaker on the very first death so the reason string is surfaced +// verbatim in the rejected WorkerPoolDispatchError. +const TRIP_ON_FIRST_DEATH = { + consecutiveFailureThreshold: 1, + maxRespawnsPerSlot: 0, +} as const; + +async function dispatchAndCatch(pool: ReturnType): Promise { + try { + await pool.dispatch<{ path: string; content: string }, unknown>([ + { path: 'src/a.ts', content: '' }, + ]); + return undefined; + } catch (e) { + return e; + } +} + +describe('worker-pool error stack propagation (#2068)', () => { + it('embeds the worker stack from a {type:error} message into the surfaced error', async () => { + const workerStack = + 'TypeError: this.#q is not a function\n' + + ' at frobnicate (/dist/core/ingestion/workers/parse-worker.js:1234:56)'; + const pool = createWorkerPool(workerUrl, 1, { + workerFactory: () => new FakeWorker() as unknown as NodeWorker, + ...TRIP_ON_FIRST_DEATH, + }); + nextActions.push({ + kind: 'error-message', + error: 'this.#q is not a function', + errorStack: workerStack, + }); + + const caught = await dispatchAndCatch(pool); + + expect(caught).toBeInstanceOf(WorkerPoolDispatchError); + const msg = (caught as Error).message; + expect(msg).toContain('this.#q is not a function'); + expect(msg).toContain('worker stack:'); + expect(msg).toContain('frobnicate (/dist/core/ingestion/workers/parse-worker.js:1234:56)'); + await pool.terminate(); + }); + + // The Node 'error' event fires on an UNCAUGHT JS throw / async rejection (which + // carries a real JS stack). A true NATIVE abort (tree-sitter SIGSEGV / OOM kill) + // instead fires the 'exit' event and is intentionally stackless — no JS frame + // exists — so it is NOT exercised here. + it('embeds the worker stack from a Node error event (uncaught throw) into the surfaced error', async () => { + const workerStack = + 'Error: uncaught worker throw\n' + + ' at processFileGroup (/dist/core/ingestion/workers/parse-worker.js:777:9)'; + const pool = createWorkerPool(workerUrl, 1, { + workerFactory: () => new FakeWorker() as unknown as NodeWorker, + ...TRIP_ON_FIRST_DEATH, + }); + nextActions.push({ kind: 'error-event', message: 'uncaught worker throw', stack: workerStack }); + + const caught = await dispatchAndCatch(pool); + + expect(caught).toBeInstanceOf(WorkerPoolDispatchError); + const msg = (caught as Error).message; + expect(msg).toContain('worker stack:'); + expect(msg).toContain('processFileGroup (/dist/core/ingestion/workers/parse-worker.js:777:9)'); + await pool.terminate(); + }); + + it('degrades to message-only when an older worker build omits errorStack', async () => { + const pool = createWorkerPool(workerUrl, 1, { + workerFactory: () => new FakeWorker() as unknown as NodeWorker, + ...TRIP_ON_FIRST_DEATH, + }); + // No errorStack — the wire field is optional for back/forward compat. + nextActions.push({ kind: 'error-message', error: 'legacy worker failure' }); + + const caught = await dispatchAndCatch(pool); + + expect(caught).toBeInstanceOf(WorkerPoolDispatchError); + const msg = (caught as Error).message; + expect(msg).toContain('legacy worker failure'); + expect(msg).not.toContain('worker stack:'); + await pool.terminate(); + }); +}); From df5ce1f49b6c6e1609c0bff1a5d2d2ce3c1d18ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gerg=C5=91=20Magyar?= Date: Mon, 8 Jun 2026 08:09:43 +0100 Subject: [PATCH 2/4] fix(ingestion): close remaining open language parsing-layer coverage gaps (#1919) (#2072) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(c): skip computed #include MACRO instead of emitting a garbage import source (F5) * fix(cpp): emit a Variable per name for structured-binding declarations (F9) * fix(dart): extract static const/final class fields (F26) * fix(dart): capture old-style function typedefs (F28) * fix(dart): read real top-level variable shape instead of a dead type field (F29) * fix(kotlin): capture callable references (F47) * fix(kotlin): anchor infix-call capture to the operator only (F49) * fix(kotlin): extract secondary constructors as members (F48) * fix(kotlin): capture destructuring declarations (F51) * fix(kotlin): index companion-object properties as fields (F52) * test(kotlin): assert callable-reference coverage runs on the worker path (F47) * fix(swift): extract protocol property requirements (F75) * fix(swift): recognize enum_class_body as a method body node (F79) * test(ingestion): rebaseline swift captures-golden + scope-capture fingerprints (#1919) * fix(kotlin): attribute secondary-constructor body calls to the Constructor node (#1919 review CF1) A Kotlin secondary constructor's body executes statements like a method body, but the registry-primary scope-resolution path had no Function scope or Constructor def for it. A call inside the body resolved its caller anchor up to the enclosing Class scope, mis-attributing the CALLS edge to the class rather than the Constructor. Add `(secondary_constructor) @scope.function` to the Kotlin scope query so the body becomes its own scope, and synthesize a `@declaration.constructor` (named `constructor`, qualified `.constructor`, with parameter metadata) so the scope owns a Constructor def that bridges to the structure-phase Constructor node. Also add an arity-disambiguating lookup key for overloadable callables: two same-name secondary constructors of different arity (e.g. a zero-arg vs a 2-arg) share the qualified key whose first-write-wins assignment is source-order- dependent — so a zero-arg overload could resolve to a sibling. The structure node id encodes `#`; mirror that in the bridge keyspace and match by the def's parameterCount. Same-arity overloads collapse onto one arity key exactly as before, so no regression there. Co-Authored-By: Claude Opus 4.8 (1M context) * fix(kotlin): do not own function-local property bindings under the enclosing class (#1919 review CF3) Kotlin emits destructuring / loop bindings (`val (a,b) = pair`, `for ((k,v) in m)`) as `@definition.property` to dodge the block-scope local-symbol pruner. When such a binding sits inside a method body of a class, the structure-phase owner walk found the enclosing class and emitted a spurious HAS_PROPERTY edge (e.g. `C -> k`), treating a function-local as a class member. Guard the Property owner resolution: if a function-like ancestor is reached before any class container, the property is function-local and gets no owner edge (it falls back to a File DEFINES edge). Language-agnostic — genuine class fields sit directly in the class body with no intervening function, so they keep their HAS_PROPERTY owner edge. Co-Authored-By: Claude Opus 4.8 (1M context) * test(kotlin): guard non-companion property isStatic=false (#1919 review CF4) Add a field-extraction case for a plain non-companion class `class C { val x: Int = 1 }` asserting the property `x` has isStatic=false, guarding the `isInsideKotlinCompanion` walk against false-positives. Co-Authored-By: Claude Opus 4.8 (1M context) * refactor(kotlin): dedup type_identifier lookup in extractOwnerName (#1919 review CF5) The `node.namedChildren.find(c => c.type === 'type_identifier')?.text` lookup was duplicated across the companion and non-companion branches of the Kotlin field-extractor's extractOwnerName. Hoist it into a single local, preserving the existing behavior (anonymous companion falls back to "Companion"; other nodes prefer the `name` field, else the type_identifier text, else undefined). Co-Authored-By: Claude Opus 4.8 (1M context) * fix(dart): capture generic old-style function typedefs (#1919 review CF2) * test(dart): guard multi-name field count and top-level-var labels (#1919 review CF4) * docs(swift): correct isStatic comment re multi-modifier hasKeyword (#1919 review CF5) * test(ingestion): rebaseline dart+kotlin scope-capture fingerprints after review remediation (#1919) * fix(ingestion): correct CF3 owner-strip boundary set for accessor/init bodies and Dart signatures (#1919 review) The CF3 property-ownership guard used FUNCTION_NODE_TYPES, which (a) includes Dart bare signatures (function_signature/method_signature) — over-stripping every Dart class getter/setter's HAS_PROPERTY owner — and (b) omits Kotlin anonymous_initializer/getter/setter and Swift computed accessors — under- stripping destructuring/locals inside init{} and accessor bodies, emitting spurious Class->local HAS_PROPERTY edges. Introduces a guard-specific LOCAL_SCOPE_BODY_NODE_TYPES set (signatures excluded, accessor/init bodies included). Adds Dart accessor-ownership + Kotlin init/accessor destructuring regression fixtures. Both confirmed on the worker pipeline; no cross-language regression (1597 cross-language tests green). --------- Co-authored-by: Claude Opus 4.8 (1M context) --- gitnexus/bench/scope-capture/baselines.json | 35 ++- .../field-extractors/configs/dart.ts | 105 ++++--- .../ingestion/field-extractors/configs/jvm.ts | 47 ++- .../field-extractors/configs/swift.ts | 37 ++- .../languages/c/import-decomposer.ts | 18 +- .../languages/cpp/import-decomposer.ts | 15 +- .../core/ingestion/languages/dart/query.ts | 40 +++ .../ingestion/languages/kotlin/captures.ts | 129 ++++++++ .../core/ingestion/languages/kotlin/query.ts | 30 ++ .../method-extractors/configs/jvm.ts | 33 +- .../method-extractors/configs/swift.ts | 15 +- .../scope-resolution/graph-bridge/ids.ts | 10 + .../graph-bridge/node-lookup.ts | 14 + .../src/core/ingestion/tree-sitter-queries.ts | 131 +++++++- .../src/core/ingestion/utils/ast-helpers.ts | 70 +++++ .../variable-extractors/configs/c-cpp.ts | 50 +++ .../variable-extractors/configs/dart.ts | 123 +++++--- .../variable-extractors/configs/jvm.ts | 45 ++- .../core/ingestion/workers/parse-worker.ts | 57 +++- .../lang-resolution/c-coverage/main.c | 9 + .../cpp-structured-binding/App.cpp | 5 + .../dart-accessor-owner/main.dart | 12 + .../dart-coverage/typedefs.dart | 5 + .../dart-static-fields/config.dart | 6 + .../dart-toplevel-vars/globals.dart | 7 + .../kotlin-companion-fields/Companions.kt | 15 + .../kotlin-coverage/callable_refs.kt | 15 + .../kotlin-destructuring/Destructuring.kt | 8 + .../kotlin-local-property-owner/Locals.kt | 31 ++ .../kotlin-secondary-ctor/Constructors.kt | 14 + .../swift-enum-members/Direction.swift | 22 ++ .../swift-protocol-property/Repository.swift | 9 + .../expected-captures.json | 8 + .../integration/resolvers/c-coverage.test.ts | 87 ++++++ .../test/integration/resolvers/cpp.test.ts | 15 + .../resolvers/dart-coverage.test.ts | 118 +++++++ .../test/integration/resolvers/dart.test.ts | 135 ++++++++ .../resolvers/kotlin-coverage.test.ts | 176 +++++++++++ .../test/integration/resolvers/kotlin.test.ts | 228 ++++++++++++++ .../test/integration/resolvers/swift.test.ts | 107 +++++++ gitnexus/test/unit/field-extraction.test.ts | 294 ++++++++++++++++++ gitnexus/test/unit/method-extraction.test.ts | 131 ++++++++ .../test/unit/variable-extraction.test.ts | 202 ++++++++++++ 43 files changed, 2514 insertions(+), 149 deletions(-) create mode 100644 gitnexus/test/fixtures/lang-resolution/c-coverage/main.c create mode 100644 gitnexus/test/fixtures/lang-resolution/dart-accessor-owner/main.dart create mode 100644 gitnexus/test/fixtures/lang-resolution/dart-coverage/typedefs.dart create mode 100644 gitnexus/test/fixtures/lang-resolution/dart-static-fields/config.dart create mode 100644 gitnexus/test/fixtures/lang-resolution/dart-toplevel-vars/globals.dart create mode 100644 gitnexus/test/fixtures/lang-resolution/kotlin-companion-fields/Companions.kt create mode 100644 gitnexus/test/fixtures/lang-resolution/kotlin-coverage/callable_refs.kt create mode 100644 gitnexus/test/fixtures/lang-resolution/kotlin-destructuring/Destructuring.kt create mode 100644 gitnexus/test/fixtures/lang-resolution/kotlin-local-property-owner/Locals.kt create mode 100644 gitnexus/test/fixtures/lang-resolution/kotlin-secondary-ctor/Constructors.kt create mode 100644 gitnexus/test/fixtures/lang-resolution/swift-enum-members/Direction.swift create mode 100644 gitnexus/test/fixtures/lang-resolution/swift-protocol-property/Repository.swift create mode 100644 gitnexus/test/integration/resolvers/c-coverage.test.ts create mode 100644 gitnexus/test/integration/resolvers/dart-coverage.test.ts create mode 100644 gitnexus/test/integration/resolvers/kotlin-coverage.test.ts diff --git a/gitnexus/bench/scope-capture/baselines.json b/gitnexus/bench/scope-capture/baselines.json index 3c3e4e0c2..79c504677 100644 --- a/gitnexus/bench/scope-capture/baselines.json +++ b/gitnexus/bench/scope-capture/baselines.json @@ -11,17 +11,18 @@ "_note": "Updated for F17-F23 fixes (P2: TIMES guard, ADD GIVING, SQL AS alias). See PR #1959." }, "c": { - "fingerprint": "39f3a8346bb58159e9d79e2db6e1dd34ec6d70028e507ffd39548667dc658aa2", + "fingerprint": "12a196b2d6249c8d86a931b12ecebc2a0cdf8d6f47683acdd0d8e9d8bc7657f5", "scaling_budget": 1.5, - "_added": "#1956: c added to the scope-capture bench (was UNBENCHED). C has no inheritance \u2014 flat scale source. Adding it exposed + fixed a pre-existing O(n^2) findNodeAtRange root-walk in c/captures.ts (threaded c.node, byte-identical over c-* fixtures); scaling 3.475 -> 0.96.", - "_note": "#1983: + c-static-linkage-worker fixture (caller.c/lib.c/lib.h/local.c \u2014 worker-path static-linkage side-channel test). Pure fixture-corpus drift: no c/captures.ts or query change branch-vs-main, existing fixtures' captures byte-identical (c-captures.test.ts 45/45), scaling stays linear (~0.97). The baseline was missed when the fixture landed; regenerated here. fingerprint 0de009b->39f3a83." + "_added": "#1956: c added to the scope-capture bench (was UNBENCHED). C has no inheritance — flat scale source. Adding it exposed + fixed a pre-existing O(n^2) findNodeAtRange root-walk in c/captures.ts (threaded c.node, byte-identical over c-* fixtures); scaling 3.475 -> 0.96.", + "_note": "#1983: + c-static-linkage-worker fixture (caller.c/lib.c/lib.h/local.c — worker-path static-linkage side-channel test). Pure fixture-corpus drift: no c/captures.ts or query change branch-vs-main, existing fixtures' captures byte-identical (c-captures.test.ts 45/45), scaling stays linear (~0.97). The baseline was missed when the fixture landed; regenerated here. fingerprint 0de009b->39f3a83.", + "_rebaselined": "#1919 open-language coverage: new lang-resolution fixtures + intended capture additions (F5/F9 c-cpp, F26/F28/F29 dart, F47/F48/F49/F51/F52 kotlin, F75/F79 swift). Fingerprint-only drift; scaling_ratio ~1.0 (linear, no perf regression)." }, "cpp": { - "fingerprint": "6d6207ae1df3943c5fae28983e0c294e55225456e7cf39af1d46fda21b6787c4", + "fingerprint": "fd3d3768cdebbb4767d7cf18b8d2df19d61de969c816d7f4d6b599f947811356", "scaling_budget": 1.5, "_added": "#1956: cpp added to the scope-capture bench (was UNBENCHED). Heritage-bearing scale source (: public Base, public Mixin) drives emitCppInheritanceCaptures at scale. Adding it exposed + fixed a pre-existing O(n^2) findNodeAtRange root-walk in cpp/captures.ts (~12 sites, threaded c.node, byte-identical over 263 cpp-* fixtures); scaling 2.30 -> 1.12.", - "_rebaselined": "#1965 / #1923 F4: uninitialized non-leading multi-declarators now emit @declaration.variable captures; cpp-adl-inner-callable-outer-noncallable data::Pair a, b adds the legitimate fixture drift. Linear (~1.06).", - "_note": "#1975: + cpp-out-of-line-class fixture, fixture_count 263->265. #1990: + cpp-adl-ns-plus-hidden-friend-same-name fixture (ADL hidden-friend + namespace-callable merge parity test). Pure fixture-corpus drift \u2014 no scope-extractor change; existing fixtures' captures byte-identical. fixture_count 265->267. #1995: + cpp-union-nested-tail-collision and cpp-anon-ns-tail-collision fixtures \u2014 pure fixture-corpus drift; fixture_count 270->272, fingerprint 538e8be->d63ded6. #1993: + cpp-cross-namespace-same-tail fixture \u2014 pure fixture-corpus drift; fixture_count 272->273, fingerprint d63ded6->6d6207ae." + "_rebaselined": "#1919 open-language coverage: new lang-resolution fixtures + intended capture additions (F5/F9 c-cpp, F26/F28/F29 dart, F47/F48/F49/F51/F52 kotlin, F75/F79 swift). Fingerprint-only drift; scaling_ratio ~1.0 (linear, no perf regression).", + "_note": "#1975: + cpp-out-of-line-class fixture, fixture_count 263->265. #1990: + cpp-adl-ns-plus-hidden-friend-same-name fixture (ADL hidden-friend + namespace-callable merge parity test). Pure fixture-corpus drift — no scope-extractor change; existing fixtures' captures byte-identical. fixture_count 265->267. #1995: + cpp-union-nested-tail-collision and cpp-anon-ns-tail-collision fixtures — pure fixture-corpus drift; fixture_count 270->272, fingerprint 538e8be->d63ded6. #1993: + cpp-cross-namespace-same-tail fixture — pure fixture-corpus drift; fixture_count 272->273, fingerprint d63ded6->6d6207ae." }, "csharp": { "_rebaselined": "#1956 synth-widening: + csharp-qualified-base fixture; the synth now walks record_declaration + struct_declaration base_lists and handles alias_qualified_name (matching the #1940 legacy leg), so record/struct heritage now emits. csharp-record-base gains a record inherits capture. (record->record SAME-namespace EXTENDS is a separate registry resolution gap, tracked as follow-up.) Linear (~1.00). (Earlier #1956: heritage-bearing scale source.) | #942: scope-resolution-only cleanup reworded fixture comments; capture byte-positions shift, capture LOGIC unchanged. | #1924 F16: record primary-constructor base bindings now exclude constructor arguments; capture fingerprint changes, scaling remains linear. | #2036 review follow-up: csharp-record-base now exercises primary-constructor base dispatch end to end; +2 capture groups, scaling remains linear.", @@ -32,8 +33,8 @@ "rust": { "fingerprint": "ac610bbe97666bf285923479dd7b43a2fe4c5354aae8df1bcbafdc04fb220f82", "scaling_budget": 1.5, - "_rebaselined": "#1956 tri-review U1: rust-qualified-trait fixture (scoped + generic-of-scoped impl trait paths); bareTypeIdentifier now resolves scoped_type_identifier bases by their name: tail (additive, no existing-fixture drift); linear (~1.04). #1975: + rust-scoped-impl fixture (impl a::Inner / b::Inner inherent scoped impls) \u2014 legacy @definition.impl scoped arm + findEnclosingClassInfo inherent-impl scoped target; rust scope-extractor captures byte-identical. | #942: scope-resolution-only cleanup reworded fixture comments; capture byte-positions shift, capture LOGIC unchanged.", - "_note": "PR #1934: F66/F68 let-binding pattern narrowing; F71 union (Struct-labeled, now materialized via legacy @definition.struct + resolvable); F72 macro FULLY WIRED \u2014 @declaration.macro/@reference.macro + MacroRegistry \u2192 USES edges to Macro nodes (never a same-named fn). + rust-macro / rust-union fixtures and merged with origin/main #1975 rust-scoped-impl; fingerprint re-baselined (scaling ~0.99, fixture_count 126). #1992: + rust-nested-tail-collision-generic and rust-generic-impl-same-method-name (F3) fixtures \u2014 pure fixture-corpus drift, no scope-extractor change; fixture_count 127->129, fingerprint 56ffc1c0->b00aea0f." + "_rebaselined": "#1956 tri-review U1: rust-qualified-trait fixture (scoped + generic-of-scoped impl trait paths); bareTypeIdentifier now resolves scoped_type_identifier bases by their name: tail (additive, no existing-fixture drift); linear (~1.04). #1975: + rust-scoped-impl fixture (impl a::Inner / b::Inner inherent scoped impls) — legacy @definition.impl scoped arm + findEnclosingClassInfo inherent-impl scoped target; rust scope-extractor captures byte-identical. | #942: scope-resolution-only cleanup reworded fixture comments; capture byte-positions shift, capture LOGIC unchanged.", + "_note": "PR #1934: F66/F68 let-binding pattern narrowing; F71 union (Struct-labeled, now materialized via legacy @definition.struct + resolvable); F72 macro FULLY WIRED — @declaration.macro/@reference.macro + MacroRegistry → USES edges to Macro nodes (never a same-named fn). + rust-macro / rust-union fixtures and merged with origin/main #1975 rust-scoped-impl; fingerprint re-baselined (scaling ~0.99, fixture_count 126). #1992: + rust-nested-tail-collision-generic and rust-generic-impl-same-method-name (F3) fixtures — pure fixture-corpus drift, no scope-extractor change; fixture_count 127->129, fingerprint 56ffc1c0->b00aea0f." }, "php": { "fingerprint": "bc2c27c5ba26d5aea61142a2a99fb772222f5b969205260eb7a71b4c0bd73cdb", @@ -45,18 +46,18 @@ "fingerprint": "b5ea93bb3d0469c3821a8c70f5d5991c6f326e41097c119ad691154301dcc753", "scaling_budget": 1.5, "_rebaselined": "#1956 synth-widening: + ruby-qualified-base fixture; synth now reduces a scope_resolution superclass (class C < Mod::Super) to its trailing constant (matching the #1940 legacy leg), at parity. Linear (~1.03). (Earlier #1956: heritage-bearing scale source.) | #942: scope-resolution-only cleanup reworded fixture comments; capture byte-positions shift, capture LOGIC unchanged.", - "_note": "F62: + scope_resolution class/module declaration captures \u2014 fixture count 78\u219281, fingerprint drift expected. #1975: + ruby-tail-collision fixture (Foo::Bar vs Baz::Bar stay distinct nodes) \u2014 pure fixture-corpus drift, scope-extractor captures unchanged; 81\u219282. #1991: + ruby-nested-mixin-tail-collision fixture (85\u219286). Recomputed on the #942 merge (fixture-comment rewording shifts capture byte-positions, capture LOGIC unchanged): bf6b13a -> b5ea93bb." + "_note": "F62: + scope_resolution class/module declaration captures — fixture count 78→81, fingerprint drift expected. #1975: + ruby-tail-collision fixture (Foo::Bar vs Baz::Bar stay distinct nodes) — pure fixture-corpus drift, scope-extractor captures unchanged; 81→82. #1991: + ruby-nested-mixin-tail-collision fixture (85→86). Recomputed on the #942 merge (fixture-comment rewording shifts capture byte-positions, capture LOGIC unchanged): bf6b13a -> b5ea93bb." }, "swift": { - "fingerprint": "53325c6345161c5a495f997297af5a24fb718fd3e6647040160f8ab2a2c8e4c0", + "fingerprint": "180ac68e780bdf6f9089d53f51cbb9a66aed3e7774631cc3fcbaae5020213998", "scaling_budget": 1.5, - "_rebaselined": "#1956: swift-qualified-base fixture + heritage-bearing scale source (class: Base, Serviceable \u2014 extends + protocol conformance); linear (~1.03)." + "_rebaselined": "#1919 open-language coverage: new lang-resolution fixtures + intended capture additions (F5/F9 c-cpp, F26/F28/F29 dart, F47/F48/F49/F51/F52 kotlin, F75/F79 swift). Fingerprint-only drift; scaling_ratio ~1.0 (linear, no perf regression)." }, "dart": { - "fingerprint": "a9e882b537765e8fd0ddfcd33b38b253dd86fc5ddffa6e4bf5a85ed8ee615eaa", + "fingerprint": "94bf2c26e1ba96f4211634aa572c0a989b503e717e75dfc5df04f66c417de80f", "scaling_budget": 1.5, "_added": "#939: dart added to the scope-capture bench with the registry-primary migration. Heritage-bearing scale source (Entity extends Base implements Marker) gates the @reference.inherits synth + the postfix-chain reference walk at scale. emitDartScopeCaptures threads tree-sitter captured nodes (no findNodeAtRange root-walk), so it is linear (~1.0).", - "_rebaselined": "#1970 review + tri-review follow-ups: constructor-call retag, cascade calls, built-in suppression, enum scope, #1926 F24/F25, named-ctor dedup (crash fix), container-name binding suppression; heritage file-affinity resolution. Fixtures: member-call-contexts, constructor-body, named-constructor-body, heritage-name-collision, construct-cascade." + "_rebaselined": "#1919 review CF3 fix: extended kotlin-local-property-owner (init/accessor destructuring) + new dart-accessor-owner fixture (getter/setter ownership). Fingerprint-only corpus drift; scaling ~1.0." }, "java": { "fingerprint": "9b29cafe32873b4902bda311bd089ffc04efe08f13557b966d29544be514080a", @@ -67,8 +68,8 @@ "typescript": { "fingerprint": "3f44a4a6892698df2d145c8ff2812c3b318807648983c88aca28fbd694f172f9", "scaling_budget": 1.5, - "_rebaselined": "#1962: F44 (class scope@), F85 (enum member declarations), F87 (optional_parameter type annotations) add new captures \u2014 fingerprint drift expected.", - "_note": "#1968: F44, F85, F87 \u2014 fingerprint drift expected." + "_rebaselined": "#1962: F44 (class scope@), F85 (enum member declarations), F87 (optional_parameter type annotations) add new captures — fingerprint drift expected.", + "_note": "#1968: F44, F85, F87 — fingerprint drift expected." }, "javascript": { "fingerprint": "d72f03c6c502235d2d4b74d66baa5c7d361f040d7a1b72e84acad61210d05ae8", @@ -77,9 +78,9 @@ "_rebaselined": "#1956 synth-widening: + javascript-qualified-base fixture; synthesizeJsInheritanceReferences now handles a member_expression base (class S extends ns.Base -> Base), matching the #1940 legacy leg + the TS terminalTsTypeNameNode property_identifier case, at parity. Linear (~1.05). | #942: scope-resolution-only cleanup reworded fixture comments; capture byte-positions shift, capture LOGIC unchanged." }, "kotlin": { - "fingerprint": "a16400622892183581b8f5f8fa01f07842d19b8cf49ed021df52bd17009d749f", + "fingerprint": "90aa832978d9744e50058e77a04748390a7e34e36b309f6c1d178eb07280b7ea", "scaling_budget": 1.5, "_added": "#1951: bench coverage added (was ungated); scale source heritage-bearing (: Base()); js/kotlin O(n^2) findNodeAtRange-per-match fixed to threaded captured node, now linear.", - "_rebaselined": "#1956 synth-widening: + kotlin-qualified-base fixture; synthesizeKotlinInheritanceReferences now handles the explicit_delegation form (class F : Iface by d -> Iface), matching the #1940 legacy leg, at parity. Linear (~0.87). | #942: scope-resolution-only cleanup reworded fixture comments; capture byte-positions shift, capture LOGIC unchanged. | #1930 F45: default parameters now emit optional-arity metadata; capture fingerprint changes, scaling remains linear." + "_rebaselined": "#1919 review CF3 fix: extended kotlin-local-property-owner (init/accessor destructuring) + new dart-accessor-owner fixture (getter/setter ownership). Fingerprint-only corpus drift; scaling ~1.0." } } diff --git a/gitnexus/src/core/ingestion/field-extractors/configs/dart.ts b/gitnexus/src/core/ingestion/field-extractors/configs/dart.ts index 52f4c0ca7..00c89b607 100644 --- a/gitnexus/src/core/ingestion/field-extractors/configs/dart.ts +++ b/gitnexus/src/core/ingestion/field-extractors/configs/dart.ts @@ -2,15 +2,59 @@ import { SupportedLanguages } from 'gitnexus-shared'; import type { FieldExtractionConfig } from '../generic.js'; +import type { FieldVisibility } from '../../field-types.js'; +import type { SyntaxNode } from '../../utils/ast-helpers.js'; import { hasKeyword } from './helpers.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; /** * Dart field extraction config. * - * Dart class fields appear as declaration nodes inside class_body. + * Dart class fields appear as `declaration` nodes inside `class_body`. + * Two shapes carry the field name(s): + * - instance / plain fields → `initialized_identifier_list` + * (`int z = 0;`, `int a = 1, b = 2;`) + * - `static const` / `static final` / `const` fields → `static_final_declaration_list` + * (`static const a = 1;`, `static final String b = 'x', c = 'y';`) + * Both shapes may declare SEVERAL fields in one declaration, so name extraction + * is multi-name (`extractNames`). The structure query (`DART_QUERIES`) emits one + * `@definition.property` per name for both shapes; this config enriches each. + * * Visibility is convention-based: underscore prefix = private. */ + +/** All field names declared by a `declaration` node, across both Dart shapes. */ +function extractDartFieldNames(node: SyntaxNode): string[] { + const names: string[] = []; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (!child) continue; + + // instance / plain fields: initialized_identifier_list > initialized_identifier > identifier + if (child.type === 'initialized_identifier_list') { + for (let j = 0; j < child.namedChildCount; j++) { + const init = child.namedChild(j); + if (init?.type === 'initialized_identifier') { + const ident = init.firstNamedChild; + if (ident?.type === 'identifier') names.push(ident.text); + } + } + } + + // static const / final fields: static_final_declaration_list > static_final_declaration > identifier + if (child.type === 'static_final_declaration_list') { + for (let j = 0; j < child.namedChildCount; j++) { + const decl = child.namedChild(j); + if (decl?.type === 'static_final_declaration') { + const ident = decl.firstNamedChild; + if (ident?.type === 'identifier') names.push(ident.text); + } + } + } + } + return names; +} + export const dartConfig: FieldExtractionConfig = { language: SupportedLanguages.Dart, typeDeclarationNodes: ['class_definition'], @@ -18,31 +62,20 @@ export const dartConfig: FieldExtractionConfig = { bodyNodeTypes: ['class_body'], defaultVisibility: 'public', + // One AST `declaration` node may declare several fields (`int a, b;`, + // `static final String b = 'x', c = 'y';`), so use the multi-name path. extractName(node) { - // declaration > initialized_identifier_list > initialized_identifier > identifier - for (let i = 0; i < node.namedChildCount; i++) { - const child = node.namedChild(i); - if (child?.type === 'initialized_identifier_list') { - for (let j = 0; j < child.namedChildCount; j++) { - const init = child.namedChild(j); - if (init?.type === 'initialized_identifier') { - const ident = init.firstNamedChild; - if (ident?.type === 'identifier') return ident.text; - } - } - } - if (child?.type === 'initialized_identifier') { - const ident = child.firstNamedChild; - if (ident?.type === 'identifier') return ident.text; - } - } - // fallback: look for direct identifier - const name = node.childForFieldName('name'); - return name?.text; + return extractDartFieldNames(node)[0]; + }, + + extractNames(node) { + return extractDartFieldNames(node); }, extractType(node) { - // declaration > type_identifier (first named child usually) + // declaration > type_identifier (the type annotation, present for both the + // instance-field shape and `static final String b = …`). `static const a = 1;` + // has no annotation → undefined (untyped). for (let i = 0; i < node.namedChildCount; i++) { const child = node.namedChild(i); if (child && (child.type === 'type_identifier' || child.type === 'function_type')) { @@ -52,22 +85,16 @@ export const dartConfig: FieldExtractionConfig = { return undefined; }, - extractVisibility(node) { - // Dart uses _ prefix for private - // Walk to find the identifier name - for (let i = 0; i < node.namedChildCount; i++) { - const child = node.namedChild(i); - if (child?.type === 'initialized_identifier_list') { - for (let j = 0; j < child.namedChildCount; j++) { - const init = child.namedChild(j); - if (init?.type === 'initialized_identifier') { - const ident = init.firstNamedChild; - if (ident?.text?.startsWith('_')) return 'private'; - } - } - } - } - return 'public'; + // Per-name: Dart convention is underscore-prefixed = private. A single + // declaration can mix visibilities (`static const _p = 1, q = 2;`), so the + // decision is keyed on the individual field name. + extractVisibilityForName(_node, name): FieldVisibility { + return name.startsWith('_') ? 'private' : 'public'; + }, + + extractVisibility(node): FieldVisibility { + const first = extractDartFieldNames(node)[0]; + return first?.startsWith('_') ? 'private' : 'public'; }, isStatic(node) { @@ -75,6 +102,8 @@ export const dartConfig: FieldExtractionConfig = { }, isReadonly(node) { + // `final` / `const` (both `final_builtin`/`const_builtin` nodes whose text + // is `final`/`const`) are read-only. return hasKeyword(node, 'final') || hasKeyword(node, 'const'); }, }; diff --git a/gitnexus/src/core/ingestion/field-extractors/configs/jvm.ts b/gitnexus/src/core/ingestion/field-extractors/configs/jvm.ts index 9d6cdbf07..37015a998 100644 --- a/gitnexus/src/core/ingestion/field-extractors/configs/jvm.ts +++ b/gitnexus/src/core/ingestion/field-extractors/configs/jvm.ts @@ -5,6 +5,7 @@ import type { FieldExtractionConfig } from '../generic.js'; import { findVisibility, hasKeyword, hasModifier, typeFromField } from './helpers.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; import type { FieldVisibility } from '../../field-types.js'; +import type { SyntaxNode } from '../../utils/ast-helpers.js'; // --------------------------------------------------------------------------- // Java @@ -73,13 +74,49 @@ export const javaConfig: FieldExtractionConfig = { const KOTLIN_VIS = new Set(['public', 'private', 'protected', 'internal']); +/** A property_declaration is a companion-object member when its nearest + * class-body ancestor is the body of a companion_object (F52, issue #1919). + * Companion members are addressed statically through the enclosing class + * (`C.TAG`), so they are marked static. */ +function isInsideKotlinCompanion(node: SyntaxNode): boolean { + for (let cur = node.parent; cur !== null; cur = cur.parent) { + if (cur.type === 'class_body') return cur.parent?.type === 'companion_object'; + if (cur.type === 'companion_object') return true; + } + return false; +} + export const kotlinConfig: FieldExtractionConfig = { language: SupportedLanguages.Kotlin, - typeDeclarationNodes: ['class_declaration', 'object_declaration'], + // F52: include companion_object so a companion property's innermost + // class-container owner (findEnclosingClassNode returns the companion_object) + // is recognized as a type declaration and its nested class_body is walked. + // The structure query already creates the Property node and owns it on the + // ENCLOSING class for anonymous companions / on the named companion Class — + // this entry only drives field-metadata enrichment, so it does NOT change + // ownership or emit a second node (no double-count). + typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'], fieldNodeTypes: ['property_declaration'], bodyNodeTypes: ['class_body'], defaultVisibility: 'public', + // F52: an anonymous `companion object { ... }` has no name child, so the + // generic factory's `childForFieldName('name')` owner lookup is empty and + // `extract()` would bail before walking the body. Supply a stable owner + // name (the named companion's identifier, else "Companion") so the body IS + // walked; the resulting FieldInfo map is keyed by field NAME only, so the + // owner name does not affect which Property node gets enriched. + extractOwnerName(node) { + const typeIdentifierText = node.namedChildren.find((c) => c.type === 'type_identifier')?.text; + if (node.type === 'companion_object') { + // Anonymous companions have no type_identifier — fall back to "Companion". + return typeIdentifierText ?? 'Companion'; + } + const name = node.childForFieldName('name'); + if (name) return name.text; + return typeIdentifierText; + }, + extractName(node) { // property_declaration > variable_declaration > simple_identifier for (let i = 0; i < node.namedChildCount; i++) { @@ -124,9 +161,11 @@ export const kotlinConfig: FieldExtractionConfig = { return findVisibility(node, KOTLIN_VIS, 'public', 'modifiers'); }, - isStatic(_node) { - // Kotlin doesn't have static; companion object members are handled separately - return false; + isStatic(node) { + // Kotlin has no `static`, but companion-object members are accessed + // statically through the enclosing class (`C.TAG`) — mark them static + // so the field metadata reflects that (F52). + return isInsideKotlinCompanion(node); }, isReadonly(node) { diff --git a/gitnexus/src/core/ingestion/field-extractors/configs/swift.ts b/gitnexus/src/core/ingestion/field-extractors/configs/swift.ts index 75c70ab95..6e27ff702 100644 --- a/gitnexus/src/core/ingestion/field-extractors/configs/swift.ts +++ b/gitnexus/src/core/ingestion/field-extractors/configs/swift.ts @@ -2,7 +2,7 @@ import { SupportedLanguages } from 'gitnexus-shared'; import type { FieldExtractionConfig } from '../generic.js'; -import { hasKeyword, findVisibility } from './helpers.js'; +import { hasKeyword, hasModifier, findVisibility } from './helpers.js'; import { extractSimpleTypeName } from '../../type-extractors/shared.js'; import type { FieldVisibility } from '../../field-types.js'; @@ -17,18 +17,33 @@ const SWIFT_VIS = new Set([ /** * Swift field extraction config. * - * Handles property_declaration inside class_body / protocol_body. + * Handles property_declaration inside class_body / protocol_body and + * protocol_property_declaration inside protocol_body (F75 — protocol property + * requirements like "var title: String { get }"). + * * tree-sitter-swift uses property_declaration for stored/computed properties. + * A protocol property requirement parses to its own node type, + * protocol_property_declaration, whose name lives in a "name:" pattern field + * (pattern > value_binding_pattern + simple_identifier(bound_identifier)), its + * type in a sibling type_annotation, and its "{ get }" / "{ get set }" in a + * protocol_property_requirements child. Note: Swift reuses the "name:" field + * across many positions (func name, every parameter label, parameter/return + * type), so the name is synthesized from the simple_identifier inside the + * pattern rather than read blindly off "name:". */ export const swiftConfig: FieldExtractionConfig = { language: SupportedLanguages.Swift, typeDeclarationNodes: ['class_declaration', 'protocol_declaration'], - fieldNodeTypes: ['property_declaration'], + fieldNodeTypes: ['property_declaration', 'protocol_property_declaration'], bodyNodeTypes: ['class_body', 'protocol_body'], defaultVisibility: 'internal', extractName(node) { - // property_declaration > pattern > simple_identifier + // property_declaration > pattern > simple_identifier, and + // protocol_property_declaration > name: (pattern ... simple_identifier). + // For protocol_property_declaration the pattern wraps a leading + // value_binding_pattern ("var") plus the simple_identifier — the loop + // below skips the binding keyword and returns the identifier. for (let i = 0; i < node.namedChildCount; i++) { const child = node.namedChild(i); if (child?.type === 'pattern') { @@ -62,7 +77,19 @@ export const swiftConfig: FieldExtractionConfig = { }, isStatic(node) { - return hasKeyword(node, 'static') || hasKeyword(node, 'class'); + // `static`/`class` (type-level) modifiers live inside a `modifiers` + // wrapper for both property_declaration and protocol_property_declaration + // (e.g. `static var shared: P { get }`), so check the wrapper too. + // `hasKeyword` compares each direct child by `.text` equality: it matches a + // single-modifier wrapper (`modifiers.text === 'static'`) but fails for a + // multi-modifier wrapper (`private static` → `modifiers.text === 'private static'`), + // which `hasModifier` handles by descending into the wrapper's children. + return ( + hasKeyword(node, 'static') || + hasKeyword(node, 'class') || + hasModifier(node, 'modifiers', 'static') || + hasModifier(node, 'modifiers', 'class') + ); }, isReadonly(node) { diff --git a/gitnexus/src/core/ingestion/languages/c/import-decomposer.ts b/gitnexus/src/core/ingestion/languages/c/import-decomposer.ts index 5cef27430..77b54f120 100644 --- a/gitnexus/src/core/ingestion/languages/c/import-decomposer.ts +++ b/gitnexus/src/core/ingestion/languages/c/import-decomposer.ts @@ -5,10 +5,20 @@ import { nodeToCapture, syntheticCapture, type SyntaxNode } from '../../utils/as * Decompose a `preproc_include` node into a CaptureMatch with structured * import captures. C #include maps to a wildcard import (all symbols * from the header are visible). + * + * Only literal include paths are emitted as import sources: + * #include → system_lib_string + * #include "local.h" → string_literal + * A computed include like `#include HEADER_MACRO` carries an `identifier` + * path node (the macro name, not a header path). Emitting it as an import + * source produces a garbage literal edge, so we skip it entirely — matching + * the convention in interpretCImport, which drops imports with no resolvable + * source (issue #1919 F5). */ export function splitCInclude(node: SyntaxNode): CaptureMatch | null { // node.type === 'preproc_include' // path field: (string_literal (string_content)) | (system_lib_string) + // | (identifier) ← computed macro include, NOT a header path const pathNode = node.childForFieldName?.('path') ?? null; if (pathNode === null) { // Fallback: scan children @@ -24,7 +34,13 @@ export function splitCInclude(node: SyntaxNode): CaptureMatch | null { return buildIncludeCapture(node, pathNode); } -function buildIncludeCapture(node: SyntaxNode, pathNode: SyntaxNode): CaptureMatch { +function buildIncludeCapture(node: SyntaxNode, pathNode: SyntaxNode): CaptureMatch | null { + // Skip computed includes (`#include MACRO`) — the path is an `identifier`, + // not a literal header path. Emitting it would create a garbage import. + if (pathNode.type !== 'string_literal' && pathNode.type !== 'system_lib_string') { + return null; + } + let raw: string; if (pathNode.type === 'string_literal') { // string_literal has children: `"`, string_content, `"` diff --git a/gitnexus/src/core/ingestion/languages/cpp/import-decomposer.ts b/gitnexus/src/core/ingestion/languages/cpp/import-decomposer.ts index eb6b252ce..ae6843923 100644 --- a/gitnexus/src/core/ingestion/languages/cpp/import-decomposer.ts +++ b/gitnexus/src/core/ingestion/languages/cpp/import-decomposer.ts @@ -5,6 +5,13 @@ import { nodeToCapture, syntheticCapture, type SyntaxNode } from '../../utils/as * Decompose a `preproc_include` node into a CaptureMatch with structured * import captures. C++ #include maps to a wildcard import (all symbols * from the header are visible). Identical to C's splitCInclude. + * + * Only literal include paths are emitted as import sources: + * #include → system_lib_string + * #include "User.h" → string_literal + * A computed include like `#include HEADER_MACRO` carries an `identifier` + * path node (the macro name, not a header path); we skip it so it never + * becomes a garbage literal import source (issue #1919 F5). */ export function splitCppInclude(node: SyntaxNode): CaptureMatch | null { const pathNode = node.childForFieldName?.('path') ?? null; @@ -21,7 +28,13 @@ export function splitCppInclude(node: SyntaxNode): CaptureMatch | null { return buildIncludeCapture(node, pathNode); } -function buildIncludeCapture(node: SyntaxNode, pathNode: SyntaxNode): CaptureMatch { +function buildIncludeCapture(node: SyntaxNode, pathNode: SyntaxNode): CaptureMatch | null { + // Skip computed includes (`#include MACRO`) — the path is an `identifier`, + // not a literal header path. Emitting it would create a garbage import. + if (pathNode.type !== 'string_literal' && pathNode.type !== 'system_lib_string') { + return null; + } + let raw: string; if (pathNode.type === 'string_literal') { const content = pathNode.namedChildren.find((c) => c.type === 'string_content'); diff --git a/gitnexus/src/core/ingestion/languages/dart/query.ts b/gitnexus/src/core/ingestion/languages/dart/query.ts index c00cfbeb5..7d66b1c4a 100644 --- a/gitnexus/src/core/ingestion/languages/dart/query.ts +++ b/gitnexus/src/core/ingestion/languages/dart/query.ts @@ -39,6 +39,46 @@ const DART_SCOPE_QUERY = ` (extension_declaration name: (identifier) @declaration.name) @declaration.class (enum_declaration name: (identifier) @declaration.name) @declaration.enum +; ── Declarations — type aliases (old-style + new-style function typedefs) ──── +; Both forms parse as type_alias; the name position differs, and a generic +; parameter list intervenes for the generic variants. Per #1919 review CF2, +; a generic type_parameters node sits between the name and the next anchor, so +; the non-generic adjacency patterns silently drop the generic forms. Four +; standalone patterns (NOT one alternation — the tree-sitter 0.21 hazard drops +; sibling branches) keep the name capture unambiguous and single-match per form: +; non-generic old-style typedef int Cmp(int a, int b); +; children: return-type, NAME, formal_parameter_list +; generic old-style typedef int Cmp(T a, T b); (CF2) +; children: return-type, NAME, type_parameters, formal_parameter_list +; non-generic new-style typedef Pred = bool Function(int); +; children: NAME, "=", function_type +; generic new-style typedef Mapper = T Function(T); +; children: NAME, type_parameters, "=", function_type +; The alias name is the type_identifier immediately before the param list (old) +; or before "=" (new); for the generic forms it is the one immediately before +; the intervening type_parameters. Mirrors Kotlin's @declaration.type_alias +; rule; the generic scope-extractor maps "type_alias" → TypeAlias. +(type_alias + (type_identifier) @declaration.name + . + (formal_parameter_list)) @declaration.type_alias +(type_alias + (type_identifier) @declaration.name + . + (type_parameters) + . + (formal_parameter_list)) @declaration.type_alias +(type_alias + (type_identifier) @declaration.name + . + "=") @declaration.type_alias +(type_alias + (type_identifier) @declaration.name + . + (type_parameters) + . + "=") @declaration.type_alias + ; ── Declarations — top-level functions (parent is program, not method) ─────── (program (function_signature diff --git a/gitnexus/src/core/ingestion/languages/kotlin/captures.ts b/gitnexus/src/core/ingestion/languages/kotlin/captures.ts index 2b14266a6..16d2a3db8 100644 --- a/gitnexus/src/core/ingestion/languages/kotlin/captures.ts +++ b/gitnexus/src/core/ingestion/languages/kotlin/captures.ts @@ -39,6 +39,7 @@ export function emitKotlinScopeCaptures( out.push(...synthesizeKotlinSmartCastBindings(tree.rootNode)); out.push(...synthesizeKotlinLambdaBindings(tree.rootNode, returnTypes)); out.push(...synthesizeKotlinInheritanceReferences(tree.rootNode)); + out.push(...synthesizeKotlinSecondaryConstructorDeclarations(tree.rootNode)); for (const match of getKotlinScopeQuery().matches(tree.rootNode)) { const grouped: Record = {}; @@ -87,6 +88,40 @@ export function emitKotlinScopeCaptures( } } + // Callable references (`::method`, `Type::new`, `obj::m`) — F47 (#1919). + // The query captures the referenced member as `@reference.name`, an + // optional receiver type as `@reference.receiver`, and the whole node as + // `@reference.callable`. Rewrite into a call reference so it participates + // in call-graph resolution: a bare `::member` resolves as a free call; + // a `Receiver::member` resolves as a member call against the receiver + // type. The function/constructor is referenced (not invoked), so no + // arity/argument metadata is attached. + if (grouped['@reference.callable'] !== undefined) { + const nameCap = grouped['@reference.name']; + const callableNode = groupedNodes['@reference.callable']; + if (nameCap !== undefined && callableNode !== undefined) { + const receiverCap = grouped['@reference.receiver']; + // The anchor Capture must carry the call-form tag as its `name` — + // the scope-extractor reads `Capture.name` (not the map key) to + // classify the reference kind, so re-wrap via nodeToCapture rather + // than reusing the `@reference.callable`-named Capture (whose head + // `callable` resolves to no ReferenceKind and silently drops it). + if (receiverCap !== undefined) { + out.push({ + '@reference.call.member': nodeToCapture('@reference.call.member', callableNode), + '@reference.name': nameCap, + '@reference.receiver': receiverCap, + }); + } else { + out.push({ + '@reference.call.free': nodeToCapture('@reference.call.free', callableNode), + '@reference.name': nameCap, + }); + } + } + continue; + } + if ( grouped['@reference.call.free'] !== undefined && grouped['@reference.receiver'] !== undefined @@ -253,6 +288,100 @@ function synthesizeKotlinInheritanceReferences(rootNode: SyntaxNode): CaptureMat return out; } +/** + * The enclosing type name for a node nested in a class/object/companion body. + * Walks up to the first `class_declaration` / `object_declaration` / + * `companion_object` ancestor and returns its `type_identifier` name node. + * Used to qualify a secondary-constructor declaration as `.constructor`. + */ +function kotlinEnclosingTypeNameNode(node: SyntaxNode): SyntaxNode | null { + for (let cur: SyntaxNode | null = node.parent; cur !== null; cur = cur.parent) { + if ( + cur.type === 'class_declaration' || + cur.type === 'object_declaration' || + cur.type === 'companion_object' + ) { + const nameNode = cur.namedChildren.find((c) => c.type === 'type_identifier'); + return nameNode ?? null; + } + } + return null; +} + +/** + * Synthesize a `@declaration.constructor` capture for each Kotlin + * `secondary_constructor` (issue #1919 review CF1). The structure phase already + * materializes a `Constructor` graph node (`Constructor:file:Class.constructor#`), + * but the registry-primary scope-resolution path had no Constructor *def* in the + * scope tree — so a call inside the constructor body resolved its caller anchor + * up to the enclosing Class def, mis-attributing the CALLS edge to the class. + * + * Paired with `(secondary_constructor) @scope.function` in query.ts: that rule + * makes the constructor body its own Function scope; this declaration places a + * Constructor def in that scope so `pickCallerCallableDef` anchors calls on the + * Constructor. The def is keyed to match the structure-phase node id: + * - `@declaration.qualified_name` = `.constructor` so the bridge's + * qualified key (`:file::Constructor::Class.constructor`) hits the node. + * - `@declaration.parameter-types` so two same-name secondary constructors are + * disambiguated by the bridge's parameter-types key (`~Int,Int`), matching + * the `#`-suffixed structure node for the overload with the same + * parameter shape. (The zero-arg overload carries no parameter types and + * resolves via the qualified/simple key to the `#0` node.) + * + * The anchor spans the whole `secondary_constructor` node — same range as the + * `@scope.function` it pairs with — so the def is owned by that Function scope + * and the constructor name auto-hoists to the enclosing class scope (exactly the + * binding shape a normal method declaration produces). + */ +function synthesizeKotlinSecondaryConstructorDeclarations(rootNode: SyntaxNode): CaptureMatch[] { + const out: CaptureMatch[] = []; + for (const ctorNode of descendantsOfType(rootNode, 'secondary_constructor')) { + const keyword = ctorNode.namedChildren.find((c) => c.type === 'constructor'); + // The `constructor` keyword is an anonymous token; fall back to the node + // itself for the name capture position when the named-child lookup misses. + const nameAnchor = keyword ?? ctorNode; + const classNameNode = kotlinEnclosingTypeNameNode(ctorNode); + const qualifiedName = + classNameNode !== null ? `${classNameNode.text}.constructor` : 'constructor'; + + const match: Record = { + '@declaration.constructor': nodeToCapture('@declaration.constructor', ctorNode), + '@declaration.name': syntheticCapture('@declaration.name', nameAnchor, 'constructor'), + '@declaration.qualified_name': syntheticCapture( + '@declaration.qualified_name', + ctorNode, + qualifiedName, + ), + }; + + const arity = computeKotlinArityMetadata(ctorNode); + if (arity.parameterCount !== undefined) { + match['@declaration.parameter-count'] = syntheticCapture( + '@declaration.parameter-count', + ctorNode, + String(arity.parameterCount), + ); + } + if (arity.requiredParameterCount !== undefined) { + match['@declaration.required-parameter-count'] = syntheticCapture( + '@declaration.required-parameter-count', + ctorNode, + String(arity.requiredParameterCount), + ); + } + if (arity.parameterTypes !== undefined) { + match['@declaration.parameter-types'] = syntheticCapture( + '@declaration.parameter-types', + ctorNode, + JSON.stringify(arity.parameterTypes), + ); + } + + out.push(match); + } + return out; +} + /** * The bare simple-name `type_identifier` of a `user_type`. Strips generic * type arguments (`Base` → `Base`) and qualifier tails (`pkg.Base` → `Base`) diff --git a/gitnexus/src/core/ingestion/languages/kotlin/query.ts b/gitnexus/src/core/ingestion/languages/kotlin/query.ts index 9209655d8..31613a38e 100644 --- a/gitnexus/src/core/ingestion/languages/kotlin/query.ts +++ b/gitnexus/src/core/ingestion/languages/kotlin/query.ts @@ -9,6 +9,16 @@ const KOTLIN_SCOPE_QUERY = ` (companion_object) @scope.class (function_declaration) @scope.function +;; Secondary-constructor body scope (issue #1919 review CF1). A +;; secondary constructor's "constructor(...) { ... }" body executes statements +;; just like a method body, so it must be its OWN Function scope — otherwise a +;; call inside the body resolves its caller anchor up to the enclosing Class +;; scope (the class's Class def), mis-attributing the CALLS edge to the class +;; rather than the Constructor. The matching @declaration.constructor is +;; synthesized in captures.ts (synthesizeKotlinSecondaryConstructorDeclarations) +;; so this scope owns a Constructor def keyed to the structure-phase node id. +(secondary_constructor) @scope.function + ;; Companion-object marker (issue #1756 / U4). Side-channel capture that ;; lets populateCompanionMembersOnEnclosingClass distinguish a companion ;; Class scope from a regular Class scope without inspecting ownedDefs. @@ -117,6 +127,26 @@ const KOTLIN_SCOPE_QUERY = ` (function_value_parameters) [(user_type) (nullable_type) (function_type)] @type-binding.type) @type-binding.return +;; References — callable references ("::method", "Type::new", "obj::m") — F47. +;; A "callable_reference" references a function/constructor as a value (no +;; call_suffix), so the registry-primary call path never saw it. Real-parse +;; (issue #1919) shows the canonical shape inside a function body is: +;; "::topLevelFn" -> (callable_reference :: (simple_identifier)) member only +;; "String::length" -> (callable_reference (type_identifier) :: (simple_identifier)) +;; "obj::method" -> (callable_reference (type_identifier) :: (simple_identifier)) +;; "Type::new" -> (callable_reference (type_identifier) :: (simple_identifier)) +;; The receiver (real type OR object) is always a "type_identifier"; the +;; referenced member is the LAST "simple_identifier". One rule with an +;; optional receiver and an end-anchored member covers all four forms with +;; exactly one match per callable_reference (no sibling-branch double-match). +;; (NOTE: a qualified "A.B::m" parses as a nested navigation_expression, not a +;; callable_reference, and is already captured by the read.member rule below.) +;; emitKotlinScopeCaptures rewrites this into a free/member call reference. +(callable_reference + (type_identifier)? @reference.receiver + (simple_identifier) @reference.name + .) @reference.callable + ;; References — direct calls / constructor syntax (call_expression (simple_identifier) @reference.name) @reference.call.free diff --git a/gitnexus/src/core/ingestion/method-extractors/configs/jvm.ts b/gitnexus/src/core/ingestion/method-extractors/configs/jvm.ts index 3233dc938..47e7773cb 100644 --- a/gitnexus/src/core/ingestion/method-extractors/configs/jvm.ts +++ b/gitnexus/src/core/ingestion/method-extractors/configs/jvm.ts @@ -186,9 +186,30 @@ function kotlinParameterHasDefaultValue(param: SyntaxNode): boolean { return false; } +/** + * Member name for a Kotlin method node. A `secondary_constructor` + * (`constructor(...) { }`) has no name child — its only identity token is + * the anonymous `constructor` keyword — so it is named "constructor" (F48, + * issue #1919), matching the @name the KOTLIN_QUERIES structure rule captures + * off that keyword so method-extractor enrichment keys (`name:line`) align. + * Multiple secondary constructors collide on this name but are disambiguated + * downstream by the `#` ID suffix the worker appends to Constructors. + */ +function extractKotlinMethodName(node: SyntaxNode): string | undefined { + if (node.type === 'secondary_constructor') return 'constructor'; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type === 'simple_identifier') return child.text; + } + return undefined; +} + function extractKotlinParameters(node: SyntaxNode): ParameterInfo[] { const params: ParameterInfo[] = []; - // Kotlin: function_declaration > function_value_parameters > parameter + // Kotlin: function_declaration / secondary_constructor > + // function_value_parameters > parameter. Both node types nest the + // parameter list the same way, so the same walk extracts a secondary + // constructor's parameters (F48). for (let i = 0; i < node.namedChildCount; i++) { const child = node.namedChild(i); if (child && child.type === 'function_value_parameters') { @@ -271,16 +292,10 @@ function extractKotlinReturnType(node: SyntaxNode): string | undefined { export const kotlinMethodConfig: MethodExtractionConfig = { language: SupportedLanguages.Kotlin, typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'], - methodNodeTypes: ['function_declaration'], + methodNodeTypes: ['function_declaration', 'secondary_constructor'], bodyNodeTypes: ['class_body'], staticOwnerTypes: new Set(['companion_object', 'object_declaration']), - extractName(node) { - for (let i = 0; i < node.namedChildCount; i++) { - const child = node.namedChild(i); - if (child?.type === 'simple_identifier') return child.text; - } - return undefined; - }, + extractName: extractKotlinMethodName, extractReturnType: extractKotlinReturnType, diff --git a/gitnexus/src/core/ingestion/method-extractors/configs/swift.ts b/gitnexus/src/core/ingestion/method-extractors/configs/swift.ts index 6c0fdfbe3..1ee630b6a 100644 --- a/gitnexus/src/core/ingestion/method-extractors/configs/swift.ts +++ b/gitnexus/src/core/ingestion/method-extractors/configs/swift.ts @@ -264,16 +264,23 @@ function extractSwiftAnnotations(node: SyntaxNode): string[] { export const swiftMethodConfig: MethodExtractionConfig = { language: SupportedLanguages.Swift, - // Keep this conservative until Swift type-shape coverage is expanded. - // TODO: Verify struct_declaration, enum_declaration, extension_declaration, actor_declaration - // node types once tree-sitter-swift loads on Node 22, and add them here if they are distinct. + // tree-sitter-swift collapses class / struct / enum / extension / actor into a + // single `class_declaration` node (distinguished by the `declaration_kind` + // field) — verified by real parse. There is NO separate `enum_declaration` + // node type, so it must NOT be listed here (it would fail the grammar-drift + // gate). The enum's owner node is therefore already covered by + // `class_declaration`; F79 only needed the enum BODY node added below. // protocol_declaration is a separate, confirmed node type. typeDeclarationNodes: ['class_declaration', 'protocol_declaration'], // function_declaration for class/struct methods, protocol_function_declaration for protocol methods methodNodeTypes: ['function_declaration', 'protocol_function_declaration'], - bodyNodeTypes: ['class_body', 'protocol_body'], + // class_body for class/struct/extension/actor, protocol_body for protocols, + // enum_class_body for enums (F79). Without enum_class_body the factory only + // reached enum methods via the generic findBodies fallback, which logs a + // dev-mode "body field type not in bodyNodeTypes" warning. + bodyNodeTypes: ['class_body', 'protocol_body', 'enum_class_body'], extractName: extractSwiftName, extractReturnType: extractSwiftReturnType, diff --git a/gitnexus/src/core/ingestion/scope-resolution/graph-bridge/ids.ts b/gitnexus/src/core/ingestion/scope-resolution/graph-bridge/ids.ts index 5da650393..7c4b57d35 100644 --- a/gitnexus/src/core/ingestion/scope-resolution/graph-bridge/ids.ts +++ b/gitnexus/src/core/ingestion/scope-resolution/graph-bridge/ids.ts @@ -115,6 +115,7 @@ export function resolveDefGraphId( type?: NodeLabel; parameterTypes?: readonly string[]; parameterTypeClasses?: readonly ParameterTypeClass[]; + parameterCount?: number; templateArguments?: readonly string[]; templateConstraints?: unknown; /** #1982 bridge-held namespace path; see `SymbolDefinition.namespacePrefix`. */ @@ -171,6 +172,15 @@ export function resolveDefGraphId( const pHit = nodeLookup.get(pKey); if (pHit !== undefined) return pHit; } + // Arity-disambiguating key (see node-lookup.ts): route a same-name overload + // to the structure node with the matching parameter count. Critical for a + // zero-arg overload (no parameterTypes) that would otherwise collapse onto a + // sibling overload via the source-order-dependent qualified key. + if (isOverloadableCallable(def.type) && def.parameterCount !== undefined) { + const aKey = qualifiedKey(filePath, def.type, `${qn}#${def.parameterCount}`); + const aHit = nodeLookup.get(aKey); + if (aHit !== undefined) return aHit; + } if ( (def.type === 'Class' || def.type === 'Struct' || diff --git a/gitnexus/src/core/ingestion/scope-resolution/graph-bridge/node-lookup.ts b/gitnexus/src/core/ingestion/scope-resolution/graph-bridge/node-lookup.ts index e39ddc4b7..9ab1649a1 100644 --- a/gitnexus/src/core/ingestion/scope-resolution/graph-bridge/node-lookup.ts +++ b/gitnexus/src/core/ingestion/scope-resolution/graph-bridge/node-lookup.ts @@ -109,6 +109,20 @@ export function buildGraphNodeLookup(graph: KnowledgeGraph): GraphNodeLookup { // Each overload is unique — set unconditionally. if (!lookup.has(pKey)) lookup.set(pKey, node.id); } + // Arity-disambiguating key: include the parameter count so two same-name + // overloads of DIFFERENT arity route to distinct graph nodes even when the + // shorter overload carries no parameter types (e.g. a Kotlin zero-arg + // secondary constructor vs a 2-arg one — both share the qualified key, whose + // first-write-wins assignment is source-order-dependent). The structure-phase + // node id encodes `#`; this mirrors it in the lookup keyspace so + // resolveDefGraphId can match by the def's own parameterCount. Same-arity + // overloads collapse onto one arity key (first-write-wins) — identical to the + // pre-existing qualified-key behavior, so no regression there. + const pCount = (props as { parameterCount?: number }).parameterCount; + if (pCount !== undefined && isOverloadableCallable(node.label)) { + const aKey = qualifiedKey(props.filePath, node.label, `${keyQualified}#${pCount}`); + if (!lookup.has(aKey)) lookup.set(aKey, node.id); + } const pClasses = (props as { parameterTypeClasses?: readonly ParameterTypeClass[] }) .parameterTypeClasses; const shapeTag = parameterShapeIdTag(pTypes, pClasses); diff --git a/gitnexus/src/core/ingestion/tree-sitter-queries.ts b/gitnexus/src/core/ingestion/tree-sitter-queries.ts index d6e25bd57..540ad1c74 100644 --- a/gitnexus/src/core/ingestion/tree-sitter-queries.ts +++ b/gitnexus/src/core/ingestion/tree-sitter-queries.ts @@ -1005,6 +1005,19 @@ export const CPP_QUERIES = ` declarator: (init_declarator declarator: (identifier) @name)) @definition.variable +; Structured bindings: auto [a, b] = makePair(); (one @name per bound identifier) +(declaration + declarator: (init_declarator + declarator: (structured_binding_declarator + (identifier) @name))) @definition.variable + +; Structured bindings, reference form: auto& [x, y] = tup; +(declaration + declarator: (init_declarator + declarator: (reference_declarator + (structured_binding_declarator + (identifier) @name)))) @definition.variable + ; Write access: obj.field = value (assignment_expression left: (field_expression @@ -1326,11 +1339,47 @@ export const KOTLIN_QUERIES = ` (function_declaration (simple_identifier) @name) @definition.function +; ── Secondary constructors (F49 sibling F48, issue #1919) ──────────────── +; "constructor(...) { }" inside a class body is a secondary_constructor with +; no name child — its only identity token is the anonymous "constructor" +; keyword, captured here as @name so the node is named "constructor" +; (matching kotlinMethodConfig.extractName). Multiple secondary constructors +; share that name but get distinct ids via the worker's # suffix. +(secondary_constructor + "constructor" @name) @definition.constructor + ; ── Properties ─────────────────────────────────────────────────────────── (property_declaration (variable_declaration (simple_identifier) @name)) @definition.property +; ── Destructuring declarations (F51, issue #1919) ──────────────────────── +; "val (a, b) = pair" binds several names through a multi_variable_declaration +; (NOT a variable_declaration), which the property rule above misses. Emit one +; @definition.property per bound name — the SAME label every other Kotlin val/var +; gets (KOTLIN_QUERIES has no @definition.variable rule, so a single "val x" +; is already a Property; matching that keeps destructured names consistent and +; out of the block-scope local-symbol pruner that drops Variable/Const/Static). +; The Kotlin "_" discard placeholder is filtered out here via (#not-eq? @name "_") +; — these locals have no enclosing class, so the field-extractor enrichment path +; never runs and cannot do the filtering itself. Each rule is a standalone +; pattern (NOT a top-level [...] alternation), so the predicate is safe under +; tree-sitter 0.21.1 (no sibling-branch drop). Loop destructuring +; "for ((k, v) in m)" nests the SAME multi_variable_declaration directly under the +; for_statement (no property_declaration wrapper); the scope-path loop binding only +; handles the single variable_declaration form, so this rule does not double-emit. +((property_declaration + (multi_variable_declaration + (variable_declaration + (simple_identifier) @name))) @definition.property + (#not-eq? @name "_")) + +((for_statement + (multi_variable_declaration + (variable_declaration + (simple_identifier) @name))) @definition.property + (#not-eq? @name "_")) + ; Primary constructor val/var parameters (data class, value class, regular class) ; binding_pattern_kind contains "val" or "var" — without it, the param is not a property (class_parameter @@ -1365,8 +1414,23 @@ export const KOTLIN_QUERIES = ` (type_identifier) @call.name)) @call ; ── Infix function calls (e.g., a to b, x until y) ────────────────────── +; tree-sitter-kotlin models infix_expression as three UNNAMED-FIELD children: +; (operand) (operator) (operand) — all three are simple_identifier for +; "a to b". The old rule "(infix_expression (simple_identifier) @call.name)" +; matched EVERY simple_identifier child, so it captured the operands a/b as +; spurious @call.name calls (F49, issue #1919). There is no operator: field to +; anchor on, so anchor positionally: the operator is the middle child, flanked +; by an operand on each side. End-anchored on both sides so only the lone +; middle simple_identifier (the infix function) is captured; chained +; "a to b to c" still matches each nested infix_expression's own operator. (infix_expression - (simple_identifier) @call.name) @call + . + (_) + . + (simple_identifier) @call.name + . + (_) + .) @call ; Write access: obj.field = value (assignment @@ -1413,6 +1477,13 @@ export const SWIFT_QUERIES = ` ; Properties (stored and computed) (property_declaration (pattern (simple_identifier) @name)) @definition.property +; Protocol property requirements (F75): "var title: String { get }" parses to a +; protocol_property_declaration (NOT property_declaration). Its name is a +; "name:" pattern field wrapping a value_binding_pattern + the bound +; simple_identifier; match the inner identifier so the requirement is emitted +; as a property symbol of the protocol. +(protocol_property_declaration (pattern (simple_identifier) @name)) @definition.property + ; Enum cases (enum_entry (simple_identifier) @name) @definition.property @@ -1459,12 +1530,36 @@ export const DART_QUERIES = ` (enum_declaration name: (identifier) @name) @definition.enum -; ── Type aliases ───────────────────────────────────────────────────────────── -; Anchor "=" after the name to avoid capturing the RHS type +; ── Type aliases — new-style (typedef Pred = bool Function(int);) ──────────── +; Anchor "=" after the name to avoid capturing the RHS type. The name is the +; first type_identifier (the alias), the RHS function_type follows the "=". (type_alias (type_identifier) @name "=") @definition.type +; ── Type aliases — old-style (typedef int Cmp(int a, int b);) ──────────────── +; The old-style function typedef has NO "=" — it parses as a type_alias whose +; children are: return type_identifier, NAME type_identifier, formal_parameter_list. +; Anchor @name as the type_identifier immediately before the parameter list so we +; capture the alias name (Cmp), not the leading return type (int). +(type_alias + (type_identifier) @name + . + (formal_parameter_list)) @definition.type + +; ── Type aliases — generic old-style (typedef int Cmp(T a, T b);) ───────── +; #1919 review CF2: a generic inserts a type_parameters node between the +; NAME and the parameter list, so the non-generic adjacency above misses it. +; Standalone pattern (NOT an alternation arm) anchoring @name immediately before +; type_parameters, which is immediately before the parameter list. The new-style +; "=" rule above is unanchored and already covers generic new-style (Mapper). +(type_alias + (type_identifier) @name + . + (type_parameters) + . + (formal_parameter_list)) @definition.type + ; ── Top-level functions (parent is program, not method_signature) ──────────── (program (function_signature @@ -1503,6 +1598,19 @@ export const DART_QUERIES = ` (initialized_identifier (identifier) @name))) @definition.property +; ── static const / static final / const class fields ──────────────────────── +; A "static const a = 1;" / "static final String b = ..., c = ...;" field parses +; with a static_final_declaration_list (NOT an initialized_identifier_list), so +; the field rules above miss them. One @name per static_final_declaration, so a +; multi-name declaration yields a Property per name. Anchored on declaration (not +; class_body) so top-level final/const variables — whose +; static_final_declaration_list is a direct child of program, not wrapped in a +; declaration — never match here. +(declaration + (static_final_declaration_list + (static_final_declaration + (identifier) @name))) @definition.property + ; ── Getters ────────────────────────────────────────────────────────────────── (method_signature (getter_signature @@ -1513,11 +1621,22 @@ export const DART_QUERIES = ` (setter_signature name: (identifier) @name)) @definition.property -; ── Top-level variable declarations (const maxSize = 100, final x = 5, var y = 0) ── -(declaration +; ── Top-level variable declarations ────────────────────────────────────────── +; Top-level Dart variables are NOT wrapped in a declaration node (that wrapper +; only occurs for class-body members). They sit as loose siblings under program: +; var name = 'x'; int x = 5; → initialized_identifier_list +; final int count = 3; const a = 1, b = 2; → static_final_declaration_list +; Anchor both rules under (program) so class-body fields (which reuse the same +; inner node types) are never matched here. One @name per declared name so +; multi-name forms (const a = 1, b = 2;) yield a Variable per name. +(program (initialized_identifier_list (initialized_identifier - (identifier) @name))) @definition.variable + (identifier) @name)) @definition.variable) +(program + (static_final_declaration_list + (static_final_declaration + (identifier) @name)) @definition.variable) ; ── Imports ────────────────────────────────────────────────────────────────── (import_or_export diff --git a/gitnexus/src/core/ingestion/utils/ast-helpers.ts b/gitnexus/src/core/ingestion/utils/ast-helpers.ts index 125c65aef..c391d7a0c 100644 --- a/gitnexus/src/core/ingestion/utils/ast-helpers.ts +++ b/gitnexus/src/core/ingestion/utils/ast-helpers.ts @@ -180,6 +180,7 @@ export const FUNCTION_NODE_TYPES = new Set([ 'anonymous_function', // Kotlin 'lambda_literal', + 'secondary_constructor', // F48: methodNodeTypes superset invariant // Swift 'init_declaration', 'deinit_declaration', @@ -583,6 +584,19 @@ export const findEnclosingClassInfo = ( ) { label = 'Interface'; } + // class_declaration with a `declaration_kind` field collapses several + // type kinds onto one node (tree-sitter-swift: class / struct / enum / + // extension / actor). The structure query labels struct → Struct and + // enum → Enum; refine the owner label to match so a member edge + // (HAS_METHOD / HAS_PROPERTY) anchors on the real Enum/Struct node id + // rather than a non-existent `Class:` id (F79). Gated on the field + // being present, so it is a no-op for grammars whose class_declaration + // has no `declaration_kind` field (e.g. Kotlin). + if (current.type === 'class_declaration' && label === 'Class') { + const declKind = current.childForFieldName?.('declaration_kind')?.text; + if (declKind === 'struct') label = 'Struct'; + else if (declKind === 'enum') label = 'Enum'; + } const templateArguments = extractTemplateArguments(nameNode.text); const classIdName = templateArguments !== undefined @@ -819,6 +833,62 @@ export const inferFunctionLabel = (nodeType: string): NodeLabel => /** Argument list node types shared between countCallArguments and call-resolution helpers. */ export const CALL_ARGUMENT_LIST_TYPES = new Set(['arguments', 'argument_list', 'value_arguments']); +/** + * Function/method parameter-list node types across grammars. Used to tell a + * PARAMETER-property (a constructor parameter that is also a class field, e.g. + * TypeScript `constructor(public name: string)`) apart from a function-BODY + * local: a property reached through one of these — rather than through the + * function's executable body — is a genuine class member, so the + * function-local-property guard must NOT strip its owner edge. + */ +export const PARAMETER_LIST_NODE_TYPES = new Set([ + 'formal_parameters', // TypeScript / JavaScript + 'parameters', // Python / C# + 'parameter_list', // Java / Go / C / Swift + 'function_value_parameters', // Kotlin + 'class_parameters', // Scala-like / future grammars +]); + +/** + * Executable local-scope boundaries for the property-ownership guard + * (`isFunctionLocalProperty` in parse-worker.ts). A `Property` capture whose + * nearest enclosing scope — walking up before any class container — is one of + * these executable bodies is a function-local binding, NOT a class member, so it + * must not receive a class `HAS_PROPERTY` owner edge. + * + * Derived from FUNCTION_NODE_TYPES, with two deliberate adjustments found by the + * #1919 review of the original guard: + * - EXCLUDES Dart's bare signature wrappers (`function_signature` / + * `method_signature`). A Dart getter/setter NAME lives under `method_signature`, + * yet it is a class-member declaration, not a local inside an executable body; + * treating the signature as a scope boundary OVER-stripped every Dart class + * accessor's owner edge. (Signatures are Dart-only; no language emits a + * legitimately-function-local Property under one.) + * - INCLUDES accessor + initializer bodies (Kotlin `anonymous_initializer` / + * `getter` / `setter`, Swift `computed_property` / `computed_getter` / + * `computed_setter` / `computed_modify`). Destructuring/locals inside these ARE + * function-local, yet they are absent from FUNCTION_NODE_TYPES; omitting them + * UNDER-stripped and emitted spurious class `HAS_PROPERTY` edges for + * `init {}` / accessor-body destructuring bindings. + * + * Kept separate from FUNCTION_NODE_TYPES because that set has many other consumers + * (e.g. enclosing-callable resolution) where signatures must remain function nodes + * and accessor bodies must not. + */ +export const LOCAL_SCOPE_BODY_NODE_TYPES: ReadonlySet = new Set( + [...FUNCTION_NODE_TYPES] + .filter((t) => t !== 'function_signature' && t !== 'method_signature') + .concat([ + 'anonymous_initializer', // Kotlin: init { } + 'getter', // Kotlin: val x get() { } + 'setter', // Kotlin: var x set(v) { } + 'computed_property', // Swift: var x: T { get set } + 'computed_getter', // Swift: get { } + 'computed_setter', // Swift: set { } + 'computed_modify', // Swift: _modify { } + ]), +); + // ============================================================================ // Generic AST traversal helpers (shared by parse-worker + php-helpers) // ============================================================================ diff --git a/gitnexus/src/core/ingestion/variable-extractors/configs/c-cpp.ts b/gitnexus/src/core/ingestion/variable-extractors/configs/c-cpp.ts index 29bf952ed..6df07b015 100644 --- a/gitnexus/src/core/ingestion/variable-extractors/configs/c-cpp.ts +++ b/gitnexus/src/core/ingestion/variable-extractors/configs/c-cpp.ts @@ -37,6 +37,55 @@ function extractCVarName(node: SyntaxNode): string | undefined { return undefined; } +/** + * Locate the `structured_binding_declarator` inside a `declaration` node, if any. + * + * C++ structured bindings (`auto [a, b] = pair;`) parse as: + * declaration → init_declarator → structured_binding_declarator → identifier+ + * The reference form (`auto& [x, y] = tup;`) wraps it one level deeper: + * declaration → init_declarator → reference_declarator → structured_binding_declarator + */ +function findStructuredBindingDeclarator(node: SyntaxNode): SyntaxNode | undefined { + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type !== 'init_declarator') continue; + const declarator = child.childForFieldName('declarator'); + if (declarator?.type === 'structured_binding_declarator') return declarator; + // `auto& [x, y]` → reference_declarator wraps the structured_binding_declarator. + if (declarator?.type === 'reference_declarator') { + const inner = declarator.namedChildren.find( + (c: SyntaxNode) => c.type === 'structured_binding_declarator', + ); + if (inner) return inner; + } + } + return undefined; +} + +/** + * Extract every bound name from a C/C++ declaration. + * + * For a structured binding `auto [a, b] = ...;` this returns each bound + * identifier (`['a', 'b']`); the binding's `structured_binding_declarator` + * lists one `identifier` per name. For an ordinary single-name declaration + * (`int n = 0;`) it falls back to the single name extractor so behaviour is + * unchanged (issue #1919 F9). + */ +function extractCVarNames(node: SyntaxNode): string[] { + const binding = findStructuredBindingDeclarator(node); + if (binding !== undefined) { + const names: string[] = []; + for (let i = 0; i < binding.namedChildCount; i++) { + const child = binding.namedChild(i); + if (child?.type === 'identifier') names.push(child.text); + } + return names; + } + + const single = extractCVarName(node); + return single !== undefined ? [single] : []; +} + function extractCVarType(node: SyntaxNode): string | undefined { const typeNode = node.childForFieldName('type'); if (typeNode) return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim(); @@ -60,6 +109,7 @@ const shared: Omit = { variableNodeTypes: ['declaration'], extractName: extractCVarName, + extractNames: extractCVarNames, extractType: extractCVarType, extractVisibility(node): VariableVisibility { diff --git a/gitnexus/src/core/ingestion/variable-extractors/configs/dart.ts b/gitnexus/src/core/ingestion/variable-extractors/configs/dart.ts index bd626212b..ee55db97b 100644 --- a/gitnexus/src/core/ingestion/variable-extractors/configs/dart.ts +++ b/gitnexus/src/core/ingestion/variable-extractors/configs/dart.ts @@ -8,56 +8,79 @@ import type { SyntaxNode } from '../../utils/ast-helpers.js'; /** * Dart variable extraction config. * - * Dart has top-level variable and constant declarations: - * - `const maxSize = 100;` - * - `final String name = "dart";` - * - `var counter = 0;` - * - `int x = 5;` + * Top-level Dart variables are NOT wrapped in a `declaration` node (that wrapper + * only occurs for class-body members). The structure query (`DART_QUERIES`) + * captures them as `@definition.variable` on the loose container node, which is + * one of two real shapes: * - * tree-sitter-dart uses: - * - declaration (with initialized_identifier_list) for file-scope variables + * - `var name = 'x';` / `int x = 5;` + * → initialized_identifier_list > initialized_identifier > identifier + * - `final int count = 3;` / `const a = 1, b = 2;` + * → static_final_declaration_list > static_final_declaration > identifier + * + * The variable extractor is invoked on that captured container node to enrich + * the Variable symbol with name(s)/type/const/mutable metadata. + * + * NOTE: the const/final modifier (`const_builtin` / `final_builtin`) and the + * type annotation (`type_identifier`) are siblings of the captured container — + * they live on the parent (program), NOT inside it — so const-ness and the type + * are read from the captured node's parent. (This is why the previous + * `type_identifier`-as-direct-child read found nothing.) */ -function extractDartVarName(node: SyntaxNode): string | undefined { - // declaration → initialized_variable_definition → identifier - for (let i = 0; i < node.namedChildCount; i++) { - const child = node.namedChild(i); - if (child?.type === 'initialized_variable_definition') { - const name = child.childForFieldName('name'); - if (name) return name.text; - // Fallback: first identifier - for (let j = 0; j < child.namedChildCount; j++) { - const gc = child.namedChild(j); - if (gc?.type === 'identifier') return gc.text; - } - } - // declaration → initialized_identifier_list → initialized_identifier → identifier - if (child?.type === 'initialized_identifier_list') { - for (let j = 0; j < child.namedChildCount; j++) { - const gc = child.namedChild(j); - if (gc?.type === 'initialized_identifier') { - const ident = gc.namedChildren.find((c: SyntaxNode) => c.type === 'identifier'); - if (ident) return ident.text; - } - } +/** The `initialized_identifier` / `static_final_declaration` name children. */ +function nameNodes(container: SyntaxNode): SyntaxNode[] { + const out: SyntaxNode[] = []; + for (let i = 0; i < container.namedChildCount; i++) { + const entry = container.namedChild(i); + if (!entry) continue; + if (entry.type === 'initialized_identifier' || entry.type === 'static_final_declaration') { + const ident = entry.firstNamedChild; + if (ident?.type === 'identifier') out.push(ident); } } - return undefined; + return out; } +function extractDartVarNames(node: SyntaxNode): string[] { + return nameNodes(node).map((n) => n.text); +} + +/** + * Scan the container's immediately-preceding siblings (the modifier / type + * nodes of THIS declaration), stopping at the previous statement's `;` so a + * neighbouring declaration's modifiers/type never bleed in. Top-level Dart + * declarations sit as loose siblings under `program` separated by `;`: + * final int count = 3; var name = 'x'; const a = 1, b = 2; + * so the leading `type_identifier` / `const_builtin` / `final_builtin` of a + * declaration are the siblings between the prior `;` and the captured container. + */ +function scanLeadingSiblings(node: SyntaxNode): SyntaxNode[] { + const out: SyntaxNode[] = []; + let sib = node.previousSibling; + while (sib !== null && sib.type !== ';') { + out.push(sib); + sib = sib.previousSibling; + } + return out; +} + +/** + * The declared type annotation, read from the captured container's leading + * sibling `type_identifier`. Returns undefined for inferred (`var`) + * declarations, which have an `inferred_type` sibling instead. + */ function extractDartVarType(node: SyntaxNode): string | undefined { - // Look for type_identifier directly on the node - for (let i = 0; i < node.namedChildCount; i++) { - const child = node.namedChild(i); - if (child?.type === 'type_identifier') return child.text; + for (const sib of scanLeadingSiblings(node)) { + if (sib.type === 'type_identifier') return sib.text; } return undefined; } -function hasDartKeyword(node: SyntaxNode, keyword: string): boolean { - for (let i = 0; i < node.childCount; i++) { - const child = node.child(i); - if (child?.text === keyword) return true; +/** Whether a `const_builtin` / `final_builtin` leads this declaration. */ +function hasReadonlyModifier(node: SyntaxNode): boolean { + for (const sib of scanLeadingSiblings(node)) { + if (sib.type === 'const_builtin' || sib.type === 'final_builtin') return true; } return false; } @@ -66,28 +89,32 @@ export const dartVariableConfig: VariableExtractionConfig = { language: SupportedLanguages.Dart, constNodeTypes: [], staticNodeTypes: [], - variableNodeTypes: ['declaration'], + // The two real top-level container shapes captured as @definition.variable. + variableNodeTypes: ['initialized_identifier_list', 'static_final_declaration_list'], - extractName: extractDartVarName, + extractName: (node) => extractDartVarNames(node)[0], + extractNames: extractDartVarNames, extractType: extractDartVarType, - extractVisibility(node): VariableVisibility { - const name = extractDartVarName(node); - if (!name) return 'public'; - // Dart convention: underscore prefix = library-private + extractVisibilityForName(_node, name): VariableVisibility { + // Dart convention: underscore prefix = library-private. return name.startsWith('_') ? 'private' : 'public'; }, - isConst(node) { - return hasDartKeyword(node, 'const') || hasDartKeyword(node, 'final'); + extractVisibility(node): VariableVisibility { + const first = extractDartVarNames(node)[0]; + if (!first) return 'public'; + return first.startsWith('_') ? 'private' : 'public'; }, + isConst: hasReadonlyModifier, + isStatic(_node) { - // Top-level Dart variables are not static + // Top-level Dart variables are not static. return false; }, isMutable(node) { - return !hasDartKeyword(node, 'const') && !hasDartKeyword(node, 'final'); + return !hasReadonlyModifier(node); }, }; diff --git a/gitnexus/src/core/ingestion/variable-extractors/configs/jvm.ts b/gitnexus/src/core/ingestion/variable-extractors/configs/jvm.ts index 6ebaa3024..4c5b96757 100644 --- a/gitnexus/src/core/ingestion/variable-extractors/configs/jvm.ts +++ b/gitnexus/src/core/ingestion/variable-extractors/configs/jvm.ts @@ -54,6 +54,19 @@ export const javaVariableConfig: VariableExtractionConfig = { }, }; +/** Single-binding name of a Kotlin property_declaration: + * property_declaration → variable_declaration → simple_identifier. */ +function kotlinSingleVarName(node: SyntaxNode): string | undefined { + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child?.type === 'variable_declaration') { + const ident = child.namedChildren.find((c: SyntaxNode) => c.type === 'simple_identifier'); + return ident?.text; + } + } + return undefined; +} + /** * Kotlin variable extraction config. * @@ -66,16 +79,32 @@ export const kotlinVariableConfig: VariableExtractionConfig = { staticNodeTypes: [], variableNodeTypes: ['property_declaration'], - extractName(node) { - // property_declaration → variable_declaration → simple_identifier - for (let i = 0; i < node.namedChildCount; i++) { - const child = node.namedChild(i); - if (child?.type === 'variable_declaration') { - const ident = child.namedChildren.find((c: SyntaxNode) => c.type === 'simple_identifier'); - return ident?.text; + extractName: kotlinSingleVarName, + + // F51 (issue #1919): destructuring declarations bind several names at one + // node. `val (a, b) = pair` parses as + // property_declaration → multi_variable_declaration + // → variable_declaration → simple_identifier (one per name) + // (real-parse-verified). The single-name `extractName` above misses these + // entirely. When a multi_variable_declaration is present we return EACH + // bound name; the Kotlin `_` placeholder is a discard and is skipped. A + // plain single declaration falls through to the existing variable_declaration + // shape so `val x = 1` still yields exactly one name (no double-count). + extractNames(node) { + const multi = node.namedChildren.find( + (c: SyntaxNode) => c.type === 'multi_variable_declaration', + ); + if (multi !== undefined) { + const names: string[] = []; + for (const decl of multi.namedChildren) { + if (decl.type !== 'variable_declaration') continue; + const ident = decl.namedChildren.find((c: SyntaxNode) => c.type === 'simple_identifier'); + if (ident !== undefined && ident.text !== '_') names.push(ident.text); } + return names; } - return undefined; + const single = kotlinSingleVarName(node); + return single !== undefined ? [single] : []; }, extractType(node) { diff --git a/gitnexus/src/core/ingestion/workers/parse-worker.ts b/gitnexus/src/core/ingestion/workers/parse-worker.ts index 9a3837494..b0f787855 100644 --- a/gitnexus/src/core/ingestion/workers/parse-worker.ts +++ b/gitnexus/src/core/ingestion/workers/parse-worker.ts @@ -58,6 +58,7 @@ import { getLanguageFromFilename } from 'gitnexus-shared'; import { buildConcreteTypedefDefinitionRanges, FUNCTION_NODE_TYPES, + findAncestorBeforeBoundary, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, @@ -69,6 +70,8 @@ import { isQualifiableScopeLabel, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, + PARAMETER_LIST_NODE_TYPES, + LOCAL_SCOPE_BODY_NODE_TYPES, type SyntaxNode, } from '../utils/ast-helpers.js'; import { extractCallArgTypes, type MixedChainStep } from '../utils/call-analysis.js'; @@ -1779,14 +1782,52 @@ const processFileGroup = ( provider.classExtractor!.qualifyScopeName?.(node, simpleName) ?? null : undefined; - const enclosingClassInfo = needsOwner - ? cachedFindEnclosingClassInfo( - nameNode || definitionNode, - file.path, - provider.resolveEnclosingOwner, - getQualifiedOwnerName, - ) - : null; + // A Property declared inside a function/lambda BODY is a function-LOCAL + // binding (e.g. Kotlin `val (a,b) = pair` or a `for ((k,v) in m)` loop + // destructuring emitted as `@definition.property` to dodge the local-symbol + // pruner), NOT a class member. Such locals must not get a HAS_PROPERTY owner + // edge from the enclosing class. Detect them by walking from the def node: + // if a function-like ancestor is reached BEFORE any class container, the + // property is enclosed by a function. Language-agnostic — genuine class + // fields sit directly in the class body with no intervening function, so + // they are unaffected (#1919 review CF3). + // + // EXCEPTION: a constructor PARAMETER property (TypeScript + // `constructor(public name: string)`) is also enclosed by a function, but + // it IS a class member — it is reached through the parameter list, not the + // executable body. So only strip the owner when the property is NOT inside + // a parameter list of that function (i.e. it's a body local). + const propOwnerNode = nameNode || definitionNode; + // A Property is function-local (and must NOT get a class HAS_PROPERTY owner) + // when its nearest enclosing executable body — reached before any class + // container — is a function/accessor/initializer body, AND it is not a + // constructor parameter-property (rescued by the param-list carve-out). + // Uses LOCAL_SCOPE_BODY_NODE_TYPES (not FUNCTION_NODE_TYPES): the latter + // mis-includes Dart bare signatures (over-stripping accessors) and omits + // Kotlin/Swift init+accessor bodies (under-stripping their locals) — see + // the #1919 review of this guard. + const isFunctionLocalProperty = + nodeLabel === 'Property' && + propOwnerNode !== undefined && + findAncestorBeforeBoundary( + propOwnerNode, + LOCAL_SCOPE_BODY_NODE_TYPES, + CLASS_CONTAINER_TYPES, + ) !== null && + findAncestorBeforeBoundary( + propOwnerNode, + PARAMETER_LIST_NODE_TYPES, + LOCAL_SCOPE_BODY_NODE_TYPES, + ) === null; + const enclosingClassInfo = + needsOwner && !isFunctionLocalProperty + ? cachedFindEnclosingClassInfo( + nameNode || definitionNode, + file.path, + provider.resolveEnclosingOwner, + getQualifiedOwnerName, + ) + : null; const enclosingClassId = enclosingClassInfo?.qualifiedClassId ?? enclosingClassInfo?.classId ?? null; const objectLiteralOwnerInfo = diff --git a/gitnexus/test/fixtures/lang-resolution/c-coverage/main.c b/gitnexus/test/fixtures/lang-resolution/c-coverage/main.c new file mode 100644 index 000000000..42cfe583d --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/c-coverage/main.c @@ -0,0 +1,9 @@ +#include +#include "local.h" + +#define HDR "computed.h" +#include HDR + +int main(void) { + return 0; +} diff --git a/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/App.cpp b/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/App.cpp index bd2e390f3..f8b6a1f87 100644 --- a/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/App.cpp +++ b/gitnexus/test/fixtures/lang-resolution/cpp-structured-binding/App.cpp @@ -15,3 +15,8 @@ void processRepoMap(std::map repoMap) { repo.save(); } } + +// F9 — plain (non-for-loop) structured binding declaration. Each bound name +// must emit its own Variable node. +std::pair makePair(); +auto [firstId, secondId] = makePair(); diff --git a/gitnexus/test/fixtures/lang-resolution/dart-accessor-owner/main.dart b/gitnexus/test/fixtures/lang-resolution/dart-accessor-owner/main.dart new file mode 100644 index 000000000..a27985a88 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/dart-accessor-owner/main.dart @@ -0,0 +1,12 @@ +// CF3 review (#1919): a Dart class getter/setter is a class-member declaration +// (its name lives under method_signature), NOT a function-local — it must keep +// its HAS_PROPERTY owner edge from the class. +class Box { + int normalField = 1; + + int get answer => 42; + + set answer(int v) { + normalField = v; + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/dart-coverage/typedefs.dart b/gitnexus/test/fixtures/lang-resolution/dart-coverage/typedefs.dart new file mode 100644 index 000000000..ac6413799 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/dart-coverage/typedefs.dart @@ -0,0 +1,5 @@ +typedef int Cmp(int a, int b); +typedef int Cmp2(T a, T b); +typedef Pred = bool Function(int); +typedef Mapper = T Function(T); +typedef int _Internal(int); diff --git a/gitnexus/test/fixtures/lang-resolution/dart-static-fields/config.dart b/gitnexus/test/fixtures/lang-resolution/dart-static-fields/config.dart new file mode 100644 index 000000000..603c7d71c --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/dart-static-fields/config.dart @@ -0,0 +1,6 @@ +class Config { + static const int maxRetries = 3; + static final String host = 'localhost', scheme = 'https'; + int port = 8080; + static const _secret = 'hidden'; +} diff --git a/gitnexus/test/fixtures/lang-resolution/dart-toplevel-vars/globals.dart b/gitnexus/test/fixtures/lang-resolution/dart-toplevel-vars/globals.dart new file mode 100644 index 000000000..a77a4de3a --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/dart-toplevel-vars/globals.dart @@ -0,0 +1,7 @@ +final int count = 3; +var name = 'x'; +const a = 1, b = 2; + +class Holder { + int z = 0; +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-companion-fields/Companions.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-companion-fields/Companions.kt new file mode 100644 index 000000000..6f823a891 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-companion-fields/Companions.kt @@ -0,0 +1,15 @@ +package coverage + +class C { + companion object { + const val TAG = "c" + val instances = 0 + fun create() {} + } +} + +class NamedComp { + companion object Factory { + val cfgX = 1 + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-coverage/callable_refs.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-coverage/callable_refs.kt new file mode 100644 index 000000000..9dee807e8 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-coverage/callable_refs.kt @@ -0,0 +1,15 @@ +package coverage + +fun topLevelFn(): Int = 1 + +class Obj { + fun method(): String = "m" +} + +fun useCallableRefs() { + val a = ::topLevelFn + val b = String::length + val obj = Obj() + val c = obj::method + val d = Type::new +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-destructuring/Destructuring.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-destructuring/Destructuring.kt new file mode 100644 index 000000000..53c421d26 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-destructuring/Destructuring.kt @@ -0,0 +1,8 @@ +package coverage + +fun useDestructuring(pair: Pair, map: Map) { + val (a, b) = pair + val (_, second) = pair + for ((k, v) in map) { } + val x = 1 +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-local-property-owner/Locals.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-local-property-owner/Locals.kt new file mode 100644 index 000000000..2a9cf86fc --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-local-property-owner/Locals.kt @@ -0,0 +1,31 @@ +package coverage + +class C(val field: Int) { + val classProp: Int = field + + // CF3 review (#1919): destructuring inside an init {} block is a + // function-local binding (anonymous_initializer is an executable body), + // NOT a class member — it must not be owned by C. + init { + val (ix, iy) = field to field + println(ix) + println(iy) + } + + // ...and the same for locals inside a property accessor (getter) body. + // `derived` is a genuine class property (owned); `gx`/`gy` are not. + val derived: Int + get() { + val (gx, gy) = field to field + return gx + gy + } + + fun process(map: Map) { + for ((k, v) in map) { + println(k) + println(v) + } + val pair = Pair(1, 2) + val (a, b) = pair + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/kotlin-secondary-ctor/Constructors.kt b/gitnexus/test/fixtures/lang-resolution/kotlin-secondary-ctor/Constructors.kt new file mode 100644 index 000000000..c34d90a54 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/kotlin-secondary-ctor/Constructors.kt @@ -0,0 +1,14 @@ +package coverage + +class Point(val x: Int) { + constructor(a: Int, b: String) : this(a) { helper() } + constructor() : this(0) { helper(); other() } + fun describe(): String = "p" +} + +class OnlyPrimary(val v: Int) { + fun method(): Int = v +} + +fun helper() {} +fun other() {} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-enum-members/Direction.swift b/gitnexus/test/fixtures/lang-resolution/swift-enum-members/Direction.swift new file mode 100644 index 000000000..c00e5a6db --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-enum-members/Direction.swift @@ -0,0 +1,22 @@ +enum Direction { + case north + case south + + func describe() -> String { + return "direction" + } + + var label: String { + return "dir" + } + + static func make() -> Direction { + return .north + } +} + +class Compass { + func heading() -> String { + return "n" + } +} diff --git a/gitnexus/test/fixtures/lang-resolution/swift-protocol-property/Repository.swift b/gitnexus/test/fixtures/lang-resolution/swift-protocol-property/Repository.swift new file mode 100644 index 000000000..700efefd4 --- /dev/null +++ b/gitnexus/test/fixtures/lang-resolution/swift-protocol-property/Repository.swift @@ -0,0 +1,9 @@ +protocol Repository { + var title: String { get } + var count: Int { get set } + static var shared: Repository { get } +} + +class FileRepository { + var name: String = "" +} diff --git a/gitnexus/test/fixtures/swift-captures-golden/expected-captures.json b/gitnexus/test/fixtures/swift-captures-golden/expected-captures.json index aabf63ddd..1482e4674 100644 --- a/gitnexus/test/fixtures/swift-captures-golden/expected-captures.json +++ b/gitnexus/test/fixtures/swift-captures-golden/expected-captures.json @@ -59,6 +59,10 @@ "captureGroups": 12, "digest": "a9c40a2dcb51c6e6a9adbaa869183eed90a81302729d4d7a0c300084ea2978e1" }, + "swift-enum-members/Direction.swift": { + "captureGroups": 18, + "digest": "6378c8860113e9d0331f4da4d05e64e6933a995493131d2f2165f64f82978b0b" + }, "swift-export-visibility/App.swift": { "captureGroups": 10, "digest": "6be49190e8a120ed1c3c3812afaa717f60fc12dae82d4b1b7158a358c53ea75a" @@ -199,6 +203,10 @@ "captureGroups": 10, "digest": "bd01b5adcd523ceee95772cc74ded0dbc1d70449fc9e9d17e975299dcbac783f" }, + "swift-protocol-property/Repository.swift": { + "captureGroups": 7, + "digest": "28e5a3c93f0dc2c0f940a6def1491d4a339e86fdc71858ecd61f4aea372afd6a" + }, "swift-qualified-base/Sources/Derived.swift": { "captureGroups": 4, "digest": "39e6ba35775ce624d1fb982204d2e2f0fcbbaf3046e317242602d9f245eb5a9d" diff --git a/gitnexus/test/integration/resolvers/c-coverage.test.ts b/gitnexus/test/integration/resolvers/c-coverage.test.ts new file mode 100644 index 000000000..7967435d0 --- /dev/null +++ b/gitnexus/test/integration/resolvers/c-coverage.test.ts @@ -0,0 +1,87 @@ +/** + * Regression tests for C/C++ scope-resolution coverage gaps (issue #1919). + * + * F5 — a computed `#include MACRO` must NOT become a literal import source. + * The macro name is an `identifier` path node (not a header path), so emitting + * it would create a garbage import edge. Literal `` (system_lib_string) + * and `"local.h"` (string_literal) includes must keep emitting correct sources. + */ +import { describe, it, expect } from 'vitest'; +import fs from 'fs'; +import path from 'path'; +import { fileURLToPath } from 'url'; +import { emitCScopeCaptures } from '../../../src/core/ingestion/languages/c/index.js'; +import { emitCppScopeCaptures } from '../../../src/core/ingestion/languages/cpp/index.js'; +import type { CaptureMatch } from 'gitnexus-shared'; + +const here = path.dirname(fileURLToPath(import.meta.url)); +const FIXTURE = path.resolve( + here, + '..', + '..', + 'fixtures', + 'lang-resolution', + 'c-coverage', + 'main.c', +); + +function importSources(matches: readonly CaptureMatch[]): string[] { + return matches + .filter((m) => m['@import.source'] !== undefined) + .map((m) => m['@import.source'].text); +} + +// --------------------------------------------------------------------------- +// F5 — computed #include MACRO is not emitted as a literal import source (C) +// --------------------------------------------------------------------------- + +describe('F5 — computed #include MACRO (C)', () => { + const src = fs.readFileSync(FIXTURE, 'utf8'); + const matches = emitCScopeCaptures(src, 'main.c') as CaptureMatch[]; + const sources = importSources(matches); + + it('emits import sources for literal and "local.h"', () => { + expect(sources).toContain('stdio.h'); + expect(sources).toContain('local.h'); + }); + + it('does NOT emit a garbage import source for #include HDR', () => { + // The macro name and any expansion text must never surface as a source. + expect(sources).not.toContain('HDR'); + expect(sources).not.toContain('computed.h'); + // Exactly the two literal includes — no spurious third source. + expect(sources).toHaveLength(2); + }); + + it('marks the system header as a system include', () => { + const systemSources = matches + .filter((m) => m['@import.system'] !== undefined) + .map((m) => m['@import.source']?.text); + expect(systemSources).toContain('stdio.h'); + expect(systemSources).not.toContain('local.h'); + }); +}); + +// --------------------------------------------------------------------------- +// F5 — computed #include MACRO is not emitted as a literal import source (C++) +// --------------------------------------------------------------------------- + +describe('F5 — computed #include MACRO (C++)', () => { + // Inline C++ source mixing literal + computed includes — the cpp decomposer + // path (splitCppInclude) is independently exercised here. + const src = + '#include \n#include "User.h"\n#define HDR "computed.h"\n#include HDR\n\nint main() { return 0; }\n'; + const matches = emitCppScopeCaptures(src, 'main.cpp') as CaptureMatch[]; + const sources = importSources(matches); + + it('emits import sources for literal and "User.h"', () => { + expect(sources).toContain('map'); + expect(sources).toContain('User.h'); + }); + + it('does NOT emit a garbage import source for #include HDR', () => { + expect(sources).not.toContain('HDR'); + expect(sources).not.toContain('computed.h'); + expect(sources).toHaveLength(2); + }); +}); diff --git a/gitnexus/test/integration/resolvers/cpp.test.ts b/gitnexus/test/integration/resolvers/cpp.test.ts index 961454c11..bfae951e3 100644 --- a/gitnexus/test/integration/resolvers/cpp.test.ts +++ b/gitnexus/test/integration/resolvers/cpp.test.ts @@ -893,6 +893,21 @@ describe('C++ structured binding in range-for', () => { ); expect(wrongSave).toBeUndefined(); }); + + // F9 — a plain structured-binding declaration emits one Variable per bound name. + it('emits a Variable for each name in `auto [firstId, secondId] = makePair();`', () => { + const vars = getNodesByLabelFull(result, 'Variable').map((v) => v.name); + expect(vars).toContain('firstId'); + expect(vars).toContain('secondId'); + }); + + it('classifies top-level structured-binding names as module scope', () => { + const bound = getNodesByLabelFull(result, 'Variable').filter( + (v) => v.name === 'firstId' || v.name === 'secondId', + ); + expect(bound).toHaveLength(2); + for (const v of bound) expect(v.properties.scope).toBe('module'); + }); }); // --------------------------------------------------------------------------- diff --git a/gitnexus/test/integration/resolvers/dart-coverage.test.ts b/gitnexus/test/integration/resolvers/dart-coverage.test.ts new file mode 100644 index 000000000..d7c0113ec --- /dev/null +++ b/gitnexus/test/integration/resolvers/dart-coverage.test.ts @@ -0,0 +1,118 @@ +/** + * Regression tests for Dart scope-resolution / structure coverage gaps + * (issue #1919). Mirrors python-parsing-coverage.test.ts: the F28 scope-capture + * assertions exercise emitDartScopeCaptures directly, and a pipeline check + * verifies the TypeAlias symbol exists end-to-end. + * + * F28 — old-style function typedef (`typedef int Cmp(int a, int b);`) was never + * captured: DART_SCOPE_QUERY had no type_alias rule, and DART_QUERIES only + * captured the new-style (`=`-anchored) form. Both forms must now surface as a + * type-alias declaration / TypeAlias symbol. + * + * #1919 review CF2 — the GENERIC forms (`typedef int Cmp2(T a, T b);` and + * `typedef Mapper = T Function(T);`) were still dropped: a generic + * type_parameters node sits between the alias name and the next anchor, so the + * non-generic adjacency patterns never matched. Standalone generic patterns now + * capture them too. + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import { emitDartScopeCaptures } from '../../../src/core/ingestion/languages/dart/captures.js'; +import { FIXTURES, getNodesByLabel, runPipelineFromRepo, type PipelineResult } from './helpers.js'; +import { + isLanguageAvailable, + loadParser, + loadLanguage, +} from '../../../src/core/tree-sitter/parser-loader.js'; +import { SupportedLanguages } from '../../../src/config/supported-languages.js'; +import type { CaptureMatch } from 'gitnexus-shared'; + +let dartAvailable = isLanguageAvailable(SupportedLanguages.Dart); +if (dartAvailable) { + try { + await loadParser(); + await loadLanguage(SupportedLanguages.Dart); + } catch { + dartAvailable = false; + } +} + +const TYPEDEFS = `typedef int Cmp(int a, int b); +typedef int Cmp2(T a, T b); +typedef Pred = bool Function(int); +typedef Mapper = T Function(T); +typedef int _Internal(int);`; + +/** All @declaration.type_alias matches, as (name) tuples. */ +function typeAliasNames(src: string): string[] { + const matches = emitDartScopeCaptures(src, 'test.dart') as CaptureMatch[]; + return matches + .filter((m) => m['@declaration.type_alias'] !== undefined) + .map((m) => m['@declaration.name']?.text) + .filter((n): n is string => Boolean(n)); +} + +// --------------------------------------------------------------------------- +// F28 — typedef capture (scope layer) +// --------------------------------------------------------------------------- + +describe.skipIf(!dartAvailable)('F28 — Dart typedef capture (scope layer)', () => { + it('captures the old-style function typedef as a type-alias declaration', () => { + const names = typeAliasNames(TYPEDEFS); + expect(names).toContain('Cmp'); + }); + + it('still captures the new-style typedef (regression)', () => { + const names = typeAliasNames(TYPEDEFS); + expect(names).toContain('Pred'); + }); + + it('captures a private old-style typedef', () => { + const names = typeAliasNames(TYPEDEFS); + expect(names).toContain('_Internal'); + }); + + it('captures the generic old-style typedef (CF2)', () => { + const names = typeAliasNames(TYPEDEFS); + expect(names).toContain('Cmp2'); + }); + + it('captures the generic new-style typedef (CF2)', () => { + const names = typeAliasNames(TYPEDEFS); + expect(names).toContain('Mapper'); + }); + + it('emits exactly one declaration per typedef (no double-match)', () => { + const names = typeAliasNames(TYPEDEFS); + expect(names.sort()).toEqual(['Cmp', 'Cmp2', 'Pred', 'Mapper', '_Internal'].sort()); + }); +}); + +// --------------------------------------------------------------------------- +// F28 — typedef symbols exist end-to-end (structure phase) +// --------------------------------------------------------------------------- + +describe.skipIf(!dartAvailable)('F28 — Dart typedef symbols (end-to-end)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'dart-coverage'), () => {}); + }, 60000); + + it('creates TypeAlias nodes for old-style, new-style, generic, and private typedefs', () => { + const aliases = getNodesByLabel(result, 'TypeAlias'); + expect(aliases).toContain('Cmp'); // old-style (covers F28) + expect(aliases).toContain('Cmp2'); // generic old-style (covers CF2) + expect(aliases).toContain('Pred'); // new-style (regression) + expect(aliases).toContain('Mapper'); // generic new-style (covers CF2) + expect(aliases).toContain('_Internal'); // private old-style + }); + + it('emits exactly one TypeAlias per typedef (no duplicates)', () => { + const aliases = getNodesByLabel(result, 'TypeAlias'); + const fromFixture = aliases.filter((n) => + ['Cmp', 'Cmp2', 'Pred', 'Mapper', '_Internal'].includes(n), + ); + expect(fromFixture.sort()).toEqual(['Cmp', 'Cmp2', 'Mapper', 'Pred', '_Internal'].sort()); + }); +}); diff --git a/gitnexus/test/integration/resolvers/dart.test.ts b/gitnexus/test/integration/resolvers/dart.test.ts index 41a2db88a..e362edc33 100644 --- a/gitnexus/test/integration/resolvers/dart.test.ts +++ b/gitnexus/test/integration/resolvers/dart.test.ts @@ -707,6 +707,118 @@ describe.skipIf(!dartAvailable)('Dart named-constructor body (no file drop)', () }); }); +// --------------------------------------------------------------------------- +// F26 (issue #1919): static const / static final class fields. +// `static const`/`static final` fields parse with a static_final_declaration_list +// (not initialized_identifier_list), so the legacy field rules missed them and +// no Property node was created end-to-end. They must surface as Property nodes +// marked static + readonly, one per name in a multi-name declaration. +// --------------------------------------------------------------------------- + +describe.skipIf(!dartAvailable)('Dart static const/final fields (F26)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'dart-static-fields'), () => {}); + }, 60000); + + it('captures static const and static final fields as Properties', () => { + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('maxRetries'); // static const + expect(properties).toContain('host'); // static final, name 1 of 2 + expect(properties).toContain('scheme'); // static final, name 2 of 2 + expect(properties).toContain('port'); // instance field (regression) + expect(properties).toContain('_secret'); // private static const + }); + + it('emits HAS_PROPERTY edges for static fields', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toEqual( + expect.arrayContaining([ + 'Config → maxRetries', + 'Config → host', + 'Config → scheme', + 'Config → port', + 'Config → _secret', + ]), + ); + }); + + it('marks static const/final fields as static + readonly', () => { + const props = getNodesByLabelFull(result, 'Property'); + for (const name of ['maxRetries', 'host', 'scheme', '_secret']) { + const p = props.find((n) => n.name === name); + expect(p, name).toBeDefined(); + expect(p!.properties.isStatic, name).toBe(true); + expect(p!.properties.isReadonly, name).toBe(true); + } + }); + + it('keeps the instance field non-static, non-readonly (regression)', () => { + const props = getNodesByLabelFull(result, 'Property'); + const port = props.find((n) => n.name === 'port'); + expect(port).toBeDefined(); + expect(port!.properties.isStatic).toBe(false); + expect(port!.properties.isReadonly).toBe(false); + }); +}); + +// --------------------------------------------------------------------------- +// F29 (issue #1919): top-level Dart variables. Top-level vars are loose +// siblings under `program` (no `declaration` wrapper), so the structure query +// never captured them and no Variable node existed end-to-end. They must now +// surface as Variable nodes with the real type/const metadata read from the +// captured container's leading siblings (not a phantom `type` field). +// --------------------------------------------------------------------------- + +describe.skipIf(!dartAvailable)('Dart top-level variables (F29)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'dart-toplevel-vars'), () => {}); + }, 60000); + + it('captures top-level variables (typed final, inferred var, multi-name const)', () => { + const vars = getNodesByLabel(result, 'Variable'); + expect(vars).toContain('count'); // final int count = 3; (covers F29) + expect(vars).toContain('name'); // var name = 'x'; + expect(vars).toContain('a'); // const a = 1, b = 2; + expect(vars).toContain('b'); + }); + + it('reads the real type for a typed final and leaves an inferred var untyped', () => { + const vars = getNodesByLabelFull(result, 'Variable'); + const count = vars.find((n) => n.name === 'count'); + expect(count).toBeDefined(); + expect(count!.properties.declaredType).toBe('int'); + expect(count!.properties.isConst).toBe(true); + + const name = vars.find((n) => n.name === 'name'); + expect(name).toBeDefined(); + // inferred `var` → no declaredType from a phantom field; mutable. + expect(name!.properties.declaredType).toBeUndefined(); + expect(name!.properties.isMutable).toBe(true); + }); + + it('keeps the class instance field as a Property, not a Variable (regression)', () => { + const vars = getNodesByLabel(result, 'Variable'); + expect(vars).not.toContain('z'); + const props = getNodesByLabel(result, 'Property'); + expect(props).toContain('z'); + }); + + it('does NOT emit top-level vars as Property nodes (#1919 review CF4)', () => { + // Guards the `(program …)` vs `(declaration …)` anchor split: top-level + // siblings under `program` must surface as Variable, never Property. If the + // top-level anchor regressed to the class-field `(declaration …)` rule, these + // names would mis-classify as class Properties. + const props = getNodesByLabel(result, 'Property'); + for (const name of ['count', 'a', 'b', 'name']) { + expect(props).not.toContain(name); + } + }); +}); + // --------------------------------------------------------------------------- // Heritage cross-file simple-name collision (PR #1970 tri-review P2). // console_logger.dart and file_logger.dart each declare `class Logger`; each @@ -736,3 +848,26 @@ describe.skipIf(!dartAvailable)('Dart heritage cross-file name collision', () => expect(fileEdge!.targetFilePath).toContain('file_logger.dart'); }); }); + +// --------------------------------------------------------------------------- +// CF3 (#1919 review): Dart class getters/setters keep their class owner edge. +// --------------------------------------------------------------------------- +// A Dart accessor's name lives under `method_signature`; the CF3 owner-strip +// guard must NOT treat that signature as an executable body and strip the +// HAS_PROPERTY owner (the over-strip regression this guards against). +describe('CF3 — Dart class accessors keep their class owner', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'dart-accessor-owner'), () => {}); + }, 60000); + + it('owns the getter/setter property `answer` and the stored field under Box', () => { + const owned = getRelationships(result, 'HAS_PROPERTY') + .filter((e) => e.source === 'Box') + .map((e) => e.target) + .sort(); + expect(owned).toContain('answer'); + expect(owned).toContain('normalField'); + }); +}); diff --git a/gitnexus/test/integration/resolvers/kotlin-coverage.test.ts b/gitnexus/test/integration/resolvers/kotlin-coverage.test.ts new file mode 100644 index 000000000..74ac3df49 --- /dev/null +++ b/gitnexus/test/integration/resolvers/kotlin-coverage.test.ts @@ -0,0 +1,176 @@ +/** + * Regression tests for Kotlin parsing-layer coverage gaps (issue #1919). + * + * Mirrors dart-coverage.test.ts / python-parsing-coverage.test.ts: the scope-layer + * assertions exercise emitKotlinScopeCaptures directly; F49 also exercises the + * legacy KOTLIN_QUERIES structure-query bank (the live spurious-edge source). + * + * F47 — callable references (`::method`, `Type::new`, `obj::method`) were never + * captured: KOTLIN_SCOPE_QUERY had no callable_reference rule, so they never + * participated in call-graph resolution. + * + * F49 — the legacy KOTLIN_QUERIES infix rule captured ALL three simple_identifier + * children of an infix_expression (`a to b` → `a`, `to`, `b`) as @call.name, + * emitting spurious call references for the operands. The fix anchors the + * capture to the operator (the middle child) only. + */ +import { describe, it, expect, beforeAll } from 'vitest'; +import path from 'path'; +import Parser from 'tree-sitter'; +import Kotlin from 'tree-sitter-kotlin'; +import { emitKotlinScopeCaptures } from '../../../src/core/ingestion/languages/kotlin/captures.js'; +import { KOTLIN_QUERIES } from '../../../src/core/ingestion/tree-sitter-queries.js'; +import { FIXTURES, getRelationships, runPipelineFromRepo, type PipelineResult } from './helpers.js'; +import type { CaptureMatch } from 'gitnexus-shared'; + +// --------------------------------------------------------------------------- +// F47 — callable references (scope layer) +// --------------------------------------------------------------------------- + +const CALLABLE_REFS = `fun useCallableRefs() { + val a = ::topLevelFn + val b = String::length + val c = obj::method + val d = Type::new +}`; + +/** All call references emitted for the source, as { name, receiver, form }. */ +function callReferences( + src: string, +): Array<{ name: string; receiver?: string; form: 'free' | 'member' }> { + const matches = emitKotlinScopeCaptures(src, 'test.kt') as CaptureMatch[]; + const out: Array<{ name: string; receiver?: string; form: 'free' | 'member' }> = []; + for (const m of matches) { + if (m['@reference.call.free'] !== undefined && m['@reference.name'] !== undefined) { + out.push({ name: m['@reference.name'].text, form: 'free' }); + } else if (m['@reference.call.member'] !== undefined && m['@reference.name'] !== undefined) { + out.push({ + name: m['@reference.name'].text, + receiver: m['@reference.receiver']?.text, + form: 'member', + }); + } + } + return out; +} + +describe('F47 — Kotlin callable references (scope layer)', () => { + it('captures a bare `::topLevelFn` reference as a free call', () => { + const refs = callReferences(CALLABLE_REFS); + const free = refs.find((r) => r.name === 'topLevelFn'); + expect(free).toBeDefined(); + expect(free!.form).toBe('free'); + }); + + it('captures `String::length` as a member call with receiver String', () => { + const refs = callReferences(CALLABLE_REFS); + const ref = refs.find((r) => r.name === 'length'); + expect(ref).toBeDefined(); + expect(ref!.form).toBe('member'); + expect(ref!.receiver).toBe('String'); + }); + + it('captures `obj::method` as a member call with receiver obj', () => { + const refs = callReferences(CALLABLE_REFS); + const ref = refs.find((r) => r.name === 'method'); + expect(ref).toBeDefined(); + expect(ref!.form).toBe('member'); + expect(ref!.receiver).toBe('obj'); + }); + + it('captures `Type::new` (constructor reference) as a member call with receiver Type', () => { + const refs = callReferences(CALLABLE_REFS); + const ref = refs.find((r) => r.name === 'new'); + expect(ref).toBeDefined(); + expect(ref!.form).toBe('member'); + expect(ref!.receiver).toBe('Type'); + }); + + it('emits exactly one call reference per callable_reference (no double-match)', () => { + const refs = callReferences(CALLABLE_REFS).filter((r) => + ['topLevelFn', 'length', 'method', 'new'].includes(r.name), + ); + expect(refs.map((r) => r.name).sort()).toEqual(['length', 'method', 'new', 'topLevelFn']); + }); + + it('does not capture the receiver type as its own free call', () => { + const refs = callReferences(CALLABLE_REFS); + // String / Type / obj are receivers, never standalone call targets. + expect(refs.some((r) => r.form === 'free' && r.name === 'String')).toBe(false); + expect(refs.some((r) => r.form === 'free' && r.name === 'Type')).toBe(false); + }); +}); + +// --------------------------------------------------------------------------- +// F47 — callable references resolve to CALLS edges end-to-end (worker path) +// --------------------------------------------------------------------------- + +describe('F47 — Kotlin callable references (end-to-end)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'kotlin-coverage'), () => {}); + }, 60000); + + it('resolves a bare `::topLevelFn` reference to a CALLS edge on the local function', () => { + const calls = getRelationships(result, 'CALLS'); + const ref = calls.find((c) => c.source === 'useCallableRefs' && c.target === 'topLevelFn'); + expect(ref).toBeDefined(); + }); + + it('resolves an `obj::method` member reference to a CALLS edge on Obj.method', () => { + const calls = getRelationships(result, 'CALLS'); + const ref = calls.find((c) => c.source === 'useCallableRefs' && c.target === 'method'); + expect(ref).toBeDefined(); + }); + + it('runs through the worker pool (parity: capture edits survive the worker boundary)', () => { + expect(result.usedWorkerPool).toBe(true); + }); +}); + +// --------------------------------------------------------------------------- +// F49 — infix-call query captures only the operator (legacy structure bank) +// --------------------------------------------------------------------------- +// +// Characterized end-to-end (issue #1919): the live spurious @call.name edges +// for `a to b` originate from the legacy KOTLIN_QUERIES bank (still wired as +// provider.treeSitterQueries / used by the worker structure phase). The +// registry KOTLIN_SCOPE_QUERY has no infix rule, so the fix is in +// tree-sitter-queries.ts only. These tests compile that live query and assert +// the call captures directly. + +/** @call.name capture texts produced by the live KOTLIN_QUERIES structure bank. */ +function structureCallNames(src: string): string[] { + const parser = new Parser(); + parser.setLanguage(Kotlin as Parameters[0]); + const query = new Parser.Query(Kotlin as Parameters[0], KOTLIN_QUERIES); + const tree = parser.parse(src); + const names: string[] = []; + for (const match of query.matches(tree.rootNode)) { + for (const c of match.captures) { + if (c.name === 'call.name') names.push(c.node.text); + } + } + return names; +} + +describe('F49 — Kotlin infix call captures only the operator', () => { + it('`val p = a to b` captures exactly one call (`to`), zero for the operands', () => { + const names = structureCallNames(`fun f() {\n val p = a to b\n}`); + expect(names).toEqual(['to']); + }); + + it('`a to b to c` captures only the `to` operators, never the operands', () => { + const names = structureCallNames(`fun f() {\n val q = a to b to c\n}`); + expect(names.sort()).toEqual(['to', 'to']); + expect(names.includes('a')).toBe(false); + expect(names.includes('b')).toBe(false); + expect(names.includes('c')).toBe(false); + }); + + it('a normal call `foo(a, b)` still produces exactly one call to `foo`', () => { + const names = structureCallNames(`fun f() {\n foo(a, b)\n}`); + expect(names).toEqual(['foo']); + }); +}); diff --git a/gitnexus/test/integration/resolvers/kotlin.test.ts b/gitnexus/test/integration/resolvers/kotlin.test.ts index 6eec8a342..9211ed605 100644 --- a/gitnexus/test/integration/resolvers/kotlin.test.ts +++ b/gitnexus/test/integration/resolvers/kotlin.test.ts @@ -2672,3 +2672,231 @@ describe('Kotlin isStaticOnly across other receiver cases (#1756 / U3)', () => { expect(createCalls.length).toBe(0); }); }); + +// --------------------------------------------------------------------------- +// F48 (issue #1919): secondary constructors are extracted as members +// --------------------------------------------------------------------------- + +describe('F48 — Kotlin secondary constructors', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'kotlin-secondary-ctor'), () => {}); + }, 60000); + + it('creates a Constructor node for each secondary constructor', () => { + // Point declares two secondary constructors; both surface as Constructors. + const ctors = getNodesByLabel(result, 'Constructor'); + expect(ctors).toEqual(['constructor', 'constructor']); + }); + + it('owns both secondary constructors under the enclosing class Point', () => { + const owned = getRelationships(result, 'HAS_METHOD').filter( + (e) => e.targetLabel === 'Constructor', + ); + expect(owned.length).toBe(2); + expect(owned.every((e) => e.source === 'Point')).toBe(true); + }); + + it('does not synthesize a constructor for a class with only a primary constructor (no double-count)', () => { + // OnlyPrimary has a primary ctor + one method, and must yield no Constructor node. + const ctorOwners = getRelationships(result, 'HAS_METHOD') + .filter((e) => e.targetLabel === 'Constructor') + .map((e) => e.source); + expect(ctorOwners).not.toContain('OnlyPrimary'); + // Its regular method is still extracted. + expect(getNodesByLabel(result, 'Method')).toContain('method'); + }); + + // ── CF1 (#1919 review): secondary-ctor body calls attribute to the Constructor ── + // The fixture's two secondary constructors call free functions in their bodies: + // constructor(a: Int, b: String) : this(a) { helper() } // arity 2 + // constructor() : this(0) { helper(); other() } // arity 0 + // Each body call must source from ITS OWN Constructor node (with the correct + // arity suffix), NOT from the File node and NOT from the enclosing Class. + it('attributes a secondary-constructor body call to the Constructor node, not File or Class', () => { + const helperCalls = getRelationships(result, 'CALLS').filter((e) => e.target === 'helper'); + // helper() is called from both secondary constructors. + expect(helperCalls.length).toBeGreaterThanOrEqual(2); + for (const call of helperCalls) { + expect(call.sourceLabel).toBe('Constructor'); + expect(call.sourceLabel).not.toBe('File'); + expect(call.sourceLabel).not.toBe('Class'); + } + }); + + it('disambiguates secondary-ctor body calls by arity (# Constructor node id)', () => { + const calls = getRelationships(result, 'CALLS'); + // `other()` is only called from the zero-arg `constructor()` body → must + // source from the arity-0 Constructor node id, never the arity-2 one. + const otherCall = calls.find((e) => e.target === 'other'); + expect(otherCall).toBeDefined(); + expect(otherCall!.sourceLabel).toBe('Constructor'); + expect(otherCall!.rel.sourceId).toBe('Constructor:Constructors.kt:Point.constructor#0'); + + // `helper()` is called from BOTH constructors; the set of caller ids must be + // exactly the two distinct arity-tagged Constructor nodes (no collapse onto one). + const helperSourceIds = new Set( + calls.filter((e) => e.target === 'helper').map((e) => e.rel.sourceId), + ); + expect(helperSourceIds).toEqual( + new Set([ + 'Constructor:Constructors.kt:Point.constructor#0', + 'Constructor:Constructors.kt:Point.constructor#2', + ]), + ); + }); + + it('still attributes a normal method body call to the Method (regression guard)', () => { + // `describe()` is an expression-body method with no call; add a sibling check + // that no secondary-ctor regression mis-routes method-owned calls. The Method + // node for `describe` exists and is owned by Point. + const describeOwned = getRelationships(result, 'HAS_METHOD').filter( + (e) => e.target === 'describe' && e.source === 'Point', + ); + expect(describeOwned.length).toBe(1); + }); +}); + +// --------------------------------------------------------------------------- +// F51 (issue #1919): destructuring declarations emit one binding per name +// --------------------------------------------------------------------------- + +describe('F51 — Kotlin destructuring declarations', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'kotlin-destructuring'), () => {}); + }, 60000); + + it('emits one binding per destructured name in `val (a, b) = pair`', () => { + const props = getNodesByLabel(result, 'Property'); + expect(props).toContain('a'); + expect(props).toContain('b'); + }); + + it('emits bindings for loop destructuring `for ((k, v) in map)`', () => { + const props = getNodesByLabel(result, 'Property'); + expect(props).toContain('k'); + expect(props).toContain('v'); + }); + + it('skips the `_` discard placeholder but keeps `second`', () => { + const props = getNodesByLabel(result, 'Property'); + expect(props).toContain('second'); + expect(props).not.toContain('_'); + }); + + it('emits exactly the expected binding set (no double-count, plain `val x` once)', () => { + const props = getNodesByLabel(result, 'Property'); + expect(props).toEqual(['a', 'b', 'k', 'second', 'v', 'x']); + }); +}); + +// --------------------------------------------------------------------------- +// CF3 (#1919 review): function-local property bindings are NOT class members +// --------------------------------------------------------------------------- +// Kotlin emits destructuring / loop bindings as `@definition.property` to dodge +// the block-scope local-symbol pruner. When such a binding sits inside a METHOD +// body of a class, it must NOT receive a HAS_PROPERTY owner edge from the class — +// it is a function-local, not a class field. Genuine class fields (primary-ctor +// `val` params and class-body `val`/`var`) must still be owned by the class. + +describe('CF3 — Kotlin function-local bindings are not class properties', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo( + path.join(FIXTURES, 'kotlin-local-property-owner'), + () => {}, + ); + }, 60000); + + it('does NOT own loop-destructuring bindings (k, v) under the enclosing class C', () => { + const owned = getRelationships(result, 'HAS_PROPERTY') + .filter((e) => e.source === 'C') + .map((e) => e.target); + expect(owned).not.toContain('k'); + expect(owned).not.toContain('v'); + }); + + it('does NOT own a `val (a, b) = pair` destructuring binding under class C', () => { + const owned = getRelationships(result, 'HAS_PROPERTY') + .filter((e) => e.source === 'C') + .map((e) => e.target); + expect(owned).not.toContain('a'); + expect(owned).not.toContain('b'); + // The intermediate `val pair` local is likewise not a class property. + expect(owned).not.toContain('pair'); + }); + + it('does NOT own destructuring inside an init {} block (ix, iy) under class C', () => { + const owned = getRelationships(result, 'HAS_PROPERTY') + .filter((e) => e.source === 'C') + .map((e) => e.target); + expect(owned).not.toContain('ix'); + expect(owned).not.toContain('iy'); + }); + + it('does NOT own destructuring inside a property accessor body (gx, gy) under class C', () => { + const owned = getRelationships(result, 'HAS_PROPERTY') + .filter((e) => e.source === 'C') + .map((e) => e.target); + expect(owned).not.toContain('gx'); + expect(owned).not.toContain('gy'); + }); + + it('still owns genuine class fields + the computed property under C, nothing else', () => { + const owned = getRelationships(result, 'HAS_PROPERTY') + .filter((e) => e.source === 'C') + .map((e) => e.target) + .sort(); + // Exact set: catches both over-strip (a real member dropped) and under-strip + // (a function-local wrongly owned). + expect(owned).toEqual(['classProp', 'derived', 'field']); + }); +}); + +// --------------------------------------------------------------------------- +// F52 (issue #1919): companion-object properties are indexed as fields +// --------------------------------------------------------------------------- + +describe('F52 — Kotlin companion-object properties', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'kotlin-companion-fields'), () => {}); + }, 60000); + + it('indexes anonymous-companion `const val TAG` as a static, readonly field', () => { + const tag = getNodesByLabelFull(result, 'Property').find((n) => n.name === 'TAG'); + expect(tag).toBeDefined(); + expect(tag!.properties.isStatic).toBe(true); + expect(tag!.properties.isReadonly).toBe(true); + }); + + it('indexes a NAMED-companion property `cfgX` as a field', () => { + const x = getNodesByLabelFull(result, 'Property').find((n) => n.name === 'cfgX'); + expect(x).toBeDefined(); + expect(x!.properties.isStatic).toBe(true); + }); + + it('emits each companion field exactly once (no double emission)', () => { + // Exact field set + a one-per-name count guards against the companion-scope + // machinery re-emitting the same property. + const props = getNodesByLabel(result, 'Property'); + expect(props).toEqual(['TAG', 'cfgX', 'instances']); + expect(props.filter((p) => p === 'TAG')).toHaveLength(1); + }); + + it('owns anonymous-companion fields on the ENCLOSING class C (companion function is not a field)', () => { + const owned = getRelationships(result, 'HAS_PROPERTY'); + const cFields = owned + .filter((e) => e.source === 'C') + .map((e) => e.target) + .sort(); + expect(cFields).toEqual(['TAG', 'instances']); + // The companion's `create` function is a Method, never a Property/field. + expect(getNodesByLabel(result, 'Property')).not.toContain('create'); + }); +}); diff --git a/gitnexus/test/integration/resolvers/swift.test.ts b/gitnexus/test/integration/resolvers/swift.test.ts index 52179d9e5..9b80d92a2 100644 --- a/gitnexus/test/integration/resolvers/swift.test.ts +++ b/gitnexus/test/integration/resolvers/swift.test.ts @@ -1250,3 +1250,110 @@ describe.skipIf(!swiftAvailable)('Swift nested-type extension (extension Foo.Bar expect(baseCall!.rel.targetId).toBe('Function:Types.swift:Bar.base#0'); }); }); + +// --------------------------------------------------------------------------- +// F75: protocol property requirements (`var title: String { get }`) are +// extracted as Property symbols owned by the protocol. Before the fix these +// protocol_property_declaration nodes were dropped (the structure query and +// field config only knew property_declaration). +// --------------------------------------------------------------------------- + +describe.skipIf(!swiftAvailable)('Swift protocol property requirements (F75)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'swift-protocol-property'), () => {}, { + skipGraphPhases: true, + }); + }, 60000); + + it('detects the Repository protocol and its property requirements', () => { + expect(getNodesByLabel(result, 'Interface')).toContain('Repository'); + const properties = getNodesByLabel(result, 'Property'); + expect(properties).toContain('title'); + expect(properties).toContain('count'); + expect(properties).toContain('shared'); + }); + + it('emits HAS_PROPERTY edges from the protocol to each requirement', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + expect(edgeSet(propEdges)).toEqual( + expect.arrayContaining(['Repository → title', 'Repository → count', 'Repository → shared']), + ); + }); + + it('populates type + static metadata on protocol requirement Property nodes', () => { + const properties = getNodesByLabelFull(result, 'Property'); + + const title = properties.find( + (p) => p.name === 'title' && p.properties.filePath === 'Repository.swift', + ); + expect(title).toBeDefined(); + expect(title!.properties.declaredType).toBe('String'); + expect(title!.properties.isStatic).toBe(false); + + const count = properties.find( + (p) => p.name === 'count' && p.properties.filePath === 'Repository.swift', + ); + expect(count).toBeDefined(); + expect(count!.properties.declaredType).toBe('Int'); + + const shared = properties.find( + (p) => p.name === 'shared' && p.properties.filePath === 'Repository.swift', + ); + expect(shared).toBeDefined(); + expect(shared!.properties.isStatic).toBe(true); + }); + + it('still extracts the class stored property exactly once (regression)', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + const nameEdges = propEdges.filter((e) => e.target === 'name' && e.source === 'FileRepository'); + expect(nameEdges).toHaveLength(1); + }); +}); + +// --------------------------------------------------------------------------- +// F79: methods/members declared inside a Swift enum (enum_class_body) are +// extracted via the proper body-node path. Before the fix they only resolved +// through the generic findBodies fallback, which logs a dev-mode warning. +// --------------------------------------------------------------------------- + +describe.skipIf(!swiftAvailable)('Swift enum members (F79)', () => { + let result: PipelineResult; + + beforeAll(async () => { + result = await runPipelineFromRepo(path.join(FIXTURES, 'swift-enum-members'), () => {}, { + skipGraphPhases: true, + }); + }, 60000); + + it('extracts enum methods owned by the enum', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const enumMethods = hasMethod + .filter((e) => e.source === 'Direction') + .map((e) => e.target) + .sort(); + expect(enumMethods).toContain('describe'); + expect(enumMethods).toContain('make'); + }); + + it('extracts each enum method exactly once (no double-count)', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const describeEdges = hasMethod.filter( + (e) => e.target === 'describe' && e.source === 'Direction', + ); + expect(describeEdges).toHaveLength(1); + }); + + it('extracts an enum computed property as a Property of the enum', () => { + const propEdges = getRelationships(result, 'HAS_PROPERTY'); + const labelEdge = propEdges.find((e) => e.target === 'label' && e.source === 'Direction'); + expect(labelEdge).toBeDefined(); + }); + + it('still extracts class methods (no regression / double-count)', () => { + const hasMethod = getRelationships(result, 'HAS_METHOD'); + const headingEdges = hasMethod.filter((e) => e.target === 'heading' && e.source === 'Compass'); + expect(headingEdges).toHaveLength(1); + }); +}); diff --git a/gitnexus/test/unit/field-extraction.test.ts b/gitnexus/test/unit/field-extraction.test.ts index 3032eeded..db6a7b0ae 100644 --- a/gitnexus/test/unit/field-extraction.test.ts +++ b/gitnexus/test/unit/field-extraction.test.ts @@ -6,6 +6,9 @@ import { pythonConfig } from '../../src/core/ingestion/field-extractors/configs/ import { goConfig } from '../../src/core/ingestion/field-extractors/configs/go.js'; import { cppConfig } from '../../src/core/ingestion/field-extractors/configs/c-cpp.js'; import { rubyConfig } from '../../src/core/ingestion/field-extractors/configs/ruby.js'; +import { dartConfig } from '../../src/core/ingestion/field-extractors/configs/dart.js'; +import { kotlinConfig } from '../../src/core/ingestion/field-extractors/configs/jvm.js'; +import { swiftConfig } from '../../src/core/ingestion/field-extractors/configs/swift.js'; import type { FieldExtractorContext } from '../../src/core/ingestion/field-types.js'; import type { TypeEnvironment } from '../../src/core/ingestion/type-env.js'; import { createSemanticModel } from '../../src/core/ingestion/model/semantic-model.js'; @@ -16,6 +19,21 @@ import Go from 'tree-sitter-go'; import Cpp from 'tree-sitter-cpp'; import Ruby from 'tree-sitter-ruby'; import CSharp from 'tree-sitter-c-sharp'; +import Dart from 'tree-sitter-dart'; + +let Kotlin: unknown; +try { + Kotlin = require('tree-sitter-kotlin'); +} catch { + // Kotlin grammar may not be installed +} + +let Swift: unknown; +try { + Swift = require('tree-sitter-swift'); +} catch { + // Swift grammar is an optional dependency; may not be installed +} import { csharpConfig as csharpFieldConfig } from '../../src/core/ingestion/field-extractors/configs/csharp.js'; import { SupportedLanguages } from '../../src/config/supported-languages.js'; @@ -1073,3 +1091,279 @@ describe('GenericFieldExtractor — C# primary constructor fields', () => { expect(countField).toBeDefined(); }); }); + +// --------------------------------------------------------------------------- +// Dart config — F26: static const / static final class fields +// --------------------------------------------------------------------------- + +describe('GenericFieldExtractor — Dart', () => { + const parser = new Parser(); + const extractor = createFieldExtractor(dartConfig); + const mockContext = createMockContext(); + mockContext.language = SupportedLanguages.Dart; + mockContext.filePath = 'test.dart'; + + it('extracts a static const field as static + readonly (F26)', () => { + parser.setLanguage(Dart); + const tree = parser.parse(`class C { + static const a = 1; +}`); + const classNode = tree.rootNode.child(0); + expect(classNode).toBeDefined(); + expect(extractor.isTypeDeclaration(classNode!)).toBe(true); + + const result = extractor.extract(classNode!, mockContext); + expect(result).not.toBeNull(); + expect(result!.ownerFqn).toBe('C'); + const a = result!.fields.find((f) => f.name === 'a'); + expect(a).toBeDefined(); + expect(a!.isStatic).toBe(true); + expect(a!.isReadonly).toBe(true); + expect(a!.visibility).toBe('public'); + }); + + it('extracts multi-name static final fields, all static + readonly (F26)', () => { + parser.setLanguage(Dart); + const tree = parser.parse(`class C { + static final String b = 'x', c = 'y'; +}`); + const classNode = tree.rootNode.child(0); + const result = extractor.extract(classNode!, mockContext); + + expect(result).not.toBeNull(); + // Exact-count guard (#1919 review CF4): `find()` below passes even on a + // double-emit, so assert b/c surface exactly twice total — one field each, + // no duplicate from the static_final_declaration_list multi-name path. + expect(result!.fields.filter((f) => f.name === 'b' || f.name === 'c')).toHaveLength(2); + const b = result!.fields.find((f) => f.name === 'b'); + const c = result!.fields.find((f) => f.name === 'c'); + expect(b).toBeDefined(); + expect(c).toBeDefined(); + for (const f of [b!, c!]) { + expect(f.isStatic).toBe(true); + expect(f.isReadonly).toBe(true); + expect(f.type).toBe('String'); + } + }); + + it('still extracts instance fields (regression)', () => { + parser.setLanguage(Dart); + const tree = parser.parse(`class C { + int z = 0; +}`); + const classNode = tree.rootNode.child(0); + const result = extractor.extract(classNode!, mockContext); + + expect(result).not.toBeNull(); + const z = result!.fields.find((f) => f.name === 'z'); + expect(z).toBeDefined(); + expect(z!.isStatic).toBe(false); + expect(z!.isReadonly).toBe(false); + expect(z!.type).toBe('int'); + }); + + it('marks an underscore-prefixed static const as private (F26)', () => { + parser.setLanguage(Dart); + const tree = parser.parse(`class C { + static const _p = 1; +}`); + const classNode = tree.rootNode.child(0); + const result = extractor.extract(classNode!, mockContext); + + expect(result).not.toBeNull(); + const p = result!.fields.find((f) => f.name === '_p'); + expect(p).toBeDefined(); + expect(p!.visibility).toBe('private'); + expect(p!.isStatic).toBe(true); + expect(p!.isReadonly).toBe(true); + }); +}); + +// --------------------------------------------------------------------------- +// Kotlin config — F52: companion-object properties indexed as fields +// --------------------------------------------------------------------------- + +const describeKotlin = Kotlin ? describe : describe.skip; + +describeKotlin('GenericFieldExtractor — Kotlin (F52 companion)', () => { + const parser = new Parser(); + const extractor = createFieldExtractor(kotlinConfig); + const mockContext = createMockContext(); + mockContext.language = SupportedLanguages.Kotlin; + mockContext.filePath = 'test.kt'; + + /** The first companion_object node in `src`. */ + function companion(src: string): Parser.SyntaxNode { + parser.setLanguage(Kotlin as Parser.Language); + const tree = parser.parse(src); + let found: Parser.SyntaxNode | undefined; + const walk = (n: Parser.SyntaxNode) => { + if (n.type === 'companion_object') found ??= n; + for (let i = 0; i < n.namedChildCount; i++) { + const c = n.namedChild(i); + if (c) walk(c); + } + }; + walk(tree.rootNode); + if (!found) throw new Error('no companion_object found'); + return found; + } + + it('extracts a `const val` companion property as a static, readonly field', () => { + const node = companion(`class C { + companion object { + const val TAG = "c" + } +}`); + expect(extractor.isTypeDeclaration(node)).toBe(true); + const result = extractor.extract(node, mockContext); + expect(result).not.toBeNull(); + const tag = result!.fields.find((f) => f.name === 'TAG'); + expect(tag).toBeDefined(); + expect(tag!.isStatic).toBe(true); + expect(tag!.isReadonly).toBe(true); + }); + + it('extracts a property from a NAMED companion object', () => { + const node = companion(`class C { + companion object Factory { + val x = 1 + } +}`); + const result = extractor.extract(node, mockContext); + const x = result!.fields.find((f) => f.name === 'x'); + expect(x).toBeDefined(); + expect(x!.isStatic).toBe(true); + expect(x!.isReadonly).toBe(true); + }); + + it('indexes only the property, not the function, and emits it exactly once', () => { + const node = companion(`class C { + companion object { + val onlyField = 1 + fun create() {} + } +}`); + const result = extractor.extract(node, mockContext); + const fieldNames = result!.fields.map((f) => f.name); + expect(fieldNames).toEqual(['onlyField']); // function excluded, no duplication + }); + + // CF4 (#1919 review): guard the new `isInsideKotlinCompanion` walk against + // false-positives — a plain (non-companion) class property must be isStatic=false. + it('reports a plain non-companion class property as isStatic=false (CF4)', () => { + const classNode = firstNodeOfType( + `class C { + val x: Int = 1 +}`, + 'class_declaration', + ); + expect(extractor.isTypeDeclaration(classNode)).toBe(true); + const result = extractor.extract(classNode, mockContext); + expect(result).not.toBeNull(); + const x = result!.fields.find((f) => f.name === 'x'); + expect(x).toBeDefined(); + expect(x!.isStatic).toBe(false); + }); + + /** Parse `src` and return the first node of the given type (depth-first). */ + function firstNodeOfType(src: string, type: string): Parser.SyntaxNode { + parser.setLanguage(Kotlin as Parser.Language); + const tree = parser.parse(src); + let found: Parser.SyntaxNode | undefined; + const walk = (n: Parser.SyntaxNode) => { + if (found) return; + if (n.type === type) { + found = n; + return; + } + for (let i = 0; i < n.namedChildCount; i++) { + const c = n.namedChild(i); + if (c) walk(c); + } + }; + walk(tree.rootNode); + if (!found) throw new Error(`no ${type} found`); + return found; + } +}); + +// --------------------------------------------------------------------------- +// Swift config — F75: protocol property requirements extracted as fields +// --------------------------------------------------------------------------- + +const describeSwift = Swift ? describe : describe.skip; + +describeSwift('GenericFieldExtractor — Swift (F75 protocol property requirements)', () => { + const parser = new Parser(); + const extractor = createFieldExtractor(swiftConfig); + const mockContext = createMockContext(); + mockContext.language = SupportedLanguages.Swift; + mockContext.filePath = 'test.swift'; + + /** Parse `src` and return the first class/protocol declaration node. */ + function declNode(src: string): Parser.SyntaxNode { + parser.setLanguage(Swift as Parser.Language); + const tree = parser.parse(src); + const node = tree.rootNode.child(0); + if (!node) throw new Error('no declaration node'); + return node; + } + + it('extracts a `{ get }` protocol property requirement as a field (F75)', () => { + const node = declNode(`protocol P { + var title: String { get } +}`); + expect(extractor.isTypeDeclaration(node)).toBe(true); + const result = extractor.extract(node, mockContext); + expect(result).not.toBeNull(); + expect(result!.ownerFqn).toBe('P'); + const title = result!.fields.find((f) => f.name === 'title'); + expect(title).toBeDefined(); + expect(title!.type).toBe('String'); + expect(title!.isStatic).toBe(false); + }); + + it('extracts a `{ get set }` protocol property requirement (F75)', () => { + const node = declNode(`protocol P { + var count: Int { get set } +}`); + const result = extractor.extract(node, mockContext); + const count = result!.fields.find((f) => f.name === 'count'); + expect(count).toBeDefined(); + expect(count!.type).toBe('Int'); + }); + + it('extracts a static protocol property requirement as static (F75)', () => { + const node = declNode(`protocol P { + static var shared: P { get } +}`); + const result = extractor.extract(node, mockContext); + const shared = result!.fields.find((f) => f.name === 'shared'); + expect(shared).toBeDefined(); + expect(shared!.type).toBe('P'); + expect(shared!.isStatic).toBe(true); + }); + + it('extracts all requirements from a multi-property protocol (F75)', () => { + const node = declNode(`protocol P { + var title: String { get } + var count: Int { get set } + static var shared: P { get } +}`); + const result = extractor.extract(node, mockContext); + const names = result!.fields.map((f) => f.name).sort(); + expect(names).toEqual(['count', 'shared', 'title']); + }); + + it('still extracts a class stored property exactly once (regression)', () => { + const node = declNode(`class C { + var name: String = "" +}`); + expect(extractor.isTypeDeclaration(node)).toBe(true); + const result = extractor.extract(node, mockContext); + const matches = result!.fields.filter((f) => f.name === 'name'); + expect(matches).toHaveLength(1); + expect(matches[0].type).toBe('String'); + }); +}); diff --git a/gitnexus/test/unit/method-extraction.test.ts b/gitnexus/test/unit/method-extraction.test.ts index 452ebc0bd..eea3b887e 100644 --- a/gitnexus/test/unit/method-extraction.test.ts +++ b/gitnexus/test/unit/method-extraction.test.ts @@ -727,6 +727,69 @@ describeKotlin('Kotlin MethodExtractor', () => { expect(result!.methods[0].isStatic).toBe(true); }); }); + + // F48 (issue #1919): secondary constructors were dropped — methodNodeTypes + // listed only 'function_declaration'. They are now extracted as members + // named "constructor" with their function_value_parameters. + describe('secondary constructors (F48)', () => { + it('extracts a secondary constructor as a member named "constructor" with its params', () => { + const tree = parseKotlin(` + class C(val x: Int) { + constructor(a: Int, b: String) : this(a) { } + } + `); + const classNode = tree.rootNode.child(0)!; + const result = extractor.extract(classNode, kotlinCtx); + + const ctor = result!.methods.find((m) => m.name === 'constructor'); + expect(ctor).toBeDefined(); + expect(ctor!.parameters.map((p) => p.name)).toEqual(['a', 'b']); + expect(ctor!.parameters[0].type).toBe('Int'); + }); + + it('extracts multiple secondary constructors distinctly (by arity)', () => { + const tree = parseKotlin(` + class C(val x: Int) { + constructor(a: Int, b: String) : this(a) { } + constructor() { } + } + `); + const classNode = tree.rootNode.child(0)!; + const result = extractor.extract(classNode, kotlinCtx); + + const ctors = result!.methods.filter((m) => m.name === 'constructor'); + expect(ctors).toHaveLength(2); + const arities = ctors.map((c) => c.parameters.length).sort(); + expect(arities).toEqual([0, 2]); + }); + + it('still extracts the secondary constructor when it delegates via : this(...)', () => { + const tree = parseKotlin(` + class C(val x: Int) { + constructor(a: Int) : this(a) { } + } + `); + const classNode = tree.rootNode.child(0)!; + const result = extractor.extract(classNode, kotlinCtx); + + const ctor = result!.methods.find((m) => m.name === 'constructor'); + expect(ctor).toBeDefined(); + expect(ctor!.parameters.map((p) => p.name)).toEqual(['a']); + }); + + it('does not synthesize a constructor member for a class with only a primary constructor + methods', () => { + const tree = parseKotlin(` + class C(val x: Int) { + fun normal(): Int = x + } + `); + const classNode = tree.rootNode.child(0)!; + const result = extractor.extract(classNode, kotlinCtx); + + expect(result!.methods.some((m) => m.name === 'constructor')).toBe(false); + expect(result!.methods.map((m) => m.name)).toEqual(['normal']); + }); + }); }); // --------------------------------------------------------------------------- @@ -4535,6 +4598,74 @@ class Child { expect(result!.methods[0].isOverride).toBe(true); }); }); + + // F79: a Swift `enum { ... }` parses to a class_declaration whose body is an + // `enum_class_body` (NOT class_body). With enum_class_body added to + // bodyNodeTypes the factory reaches enum methods via the proper body-node + // path instead of the generic findBodies fallback. + describe('enum members (F79)', () => { + it('extracts a method declared inside an enum', () => { + const tree = parseSwift(` +enum E { + case a + func describe() -> String { + return "x" + } +} + `); + const enumNode = tree.rootNode.child(0)!; + expect(enumNode.type).toBe('class_declaration'); + expect(extractor.isTypeDeclaration(enumNode)).toBe(true); + + const result = extractor.extract(enumNode, swiftCtx); + expect(result!.ownerName).toBe('E'); + const describe = result!.methods.find((m) => m.name === 'describe'); + expect(describe).toBeDefined(); + expect(describe!.returnType).toBe('String'); + }); + + it('extracts a static method inside an enum as static', () => { + const tree = parseSwift(` +enum E { + case a + static func make() -> E { + return .a + } +} + `); + const enumNode = tree.rootNode.child(0)!; + const result = extractor.extract(enumNode, swiftCtx); + const make = result!.methods.find((m) => m.name === 'make'); + expect(make).toBeDefined(); + expect(make!.isStatic).toBe(true); + }); + + it('extracts multiple enum methods, each exactly once', () => { + const tree = parseSwift(` +enum E { + case a + func describe() -> String { return "x" } + static func make() -> E { return .a } +} + `); + const enumNode = tree.rootNode.child(0)!; + const result = extractor.extract(enumNode, swiftCtx); + const names = result!.methods.map((m) => m.name).sort(); + expect(names).toEqual(['describe', 'make']); + }); + + it('still extracts class methods exactly once (regression)', () => { + const tree = parseSwift(` +class Compass { + func heading() -> String { return "n" } +} + `); + const classNode = tree.rootNode.child(0)!; + const result = extractor.extract(classNode, swiftCtx); + const heading = result!.methods.filter((m) => m.name === 'heading'); + expect(heading).toHaveLength(1); + }); + }); }); // --------------------------------------------------------------------------- diff --git a/gitnexus/test/unit/variable-extraction.test.ts b/gitnexus/test/unit/variable-extraction.test.ts index e7a8be1ce..4c39f0165 100644 --- a/gitnexus/test/unit/variable-extraction.test.ts +++ b/gitnexus/test/unit/variable-extraction.test.ts @@ -12,6 +12,9 @@ import { cppVariableConfig, } from '../../src/core/ingestion/variable-extractors/configs/c-cpp.js'; import { rubyVariableConfig } from '../../src/core/ingestion/variable-extractors/configs/ruby.js'; +import { dartVariableConfig } from '../../src/core/ingestion/variable-extractors/configs/dart.js'; +import { kotlinVariableConfig } from '../../src/core/ingestion/variable-extractors/configs/jvm.js'; +import type { SyntaxNode } from '../../src/core/ingestion/utils/ast-helpers.js'; import type { VariableExtractorContext } from '../../src/core/ingestion/variable-types.js'; import { SupportedLanguages } from '../../src/config/supported-languages.js'; import Parser from 'tree-sitter'; @@ -22,6 +25,14 @@ import Rust from 'tree-sitter-rust'; import Cpp from 'tree-sitter-cpp'; import C from 'tree-sitter-c'; import Ruby from 'tree-sitter-ruby'; +import Dart from 'tree-sitter-dart'; + +let Kotlin: unknown; +try { + Kotlin = require('tree-sitter-kotlin'); +} catch { + // Kotlin grammar may not be installed +} const parser = new Parser(); @@ -473,6 +484,41 @@ describe('VariableExtractor — C++', () => { expect(info!.name).toBe('SIZE'); expect(info!.isConst).toBe(true); }); + + // F9 — structured binding declarations emit one Variable per bound name. + it('emits a Variable per name for `auto [a, b] = make_pair();`', () => { + parser.setLanguage(Cpp); + const tree = parser.parse('auto [a, b] = make_pair();'); + const node = tree.rootNode.child(0)!; + expect(extractor.isVariableDeclaration(node)).toBe(true); + + const infos = extractor.extractAll(node, ctx); + expect(infos.map((i) => i.name)).toEqual(['a', 'b']); + // Top-level declaration → module scope (C++ is in the safe set re: the + // determineScope class-body block hazard). + for (const info of infos) expect(info.scope).toBe('module'); + }); + + it('emits a Variable per name for the reference form `auto& [x, y, z] = tup;`', () => { + parser.setLanguage(Cpp); + const tree = parser.parse('auto& [x, y, z] = tup;'); + const node = tree.rootNode.child(0)!; + + const infos = extractor.extractAll(node, ctx); + expect(infos.map((i) => i.name)).toEqual(['x', 'y', 'z']); + for (const info of infos) expect(info.scope).toBe('module'); + }); + + it('does not double-emit for an ordinary single-name declaration `int n = 0;`', () => { + parser.setLanguage(Cpp); + const tree = parser.parse('int n = 0;'); + const node = tree.rootNode.child(0)!; + + const infos = extractor.extractAll(node, ctx); + expect(infos).toHaveLength(1); + expect(infos[0]!.name).toBe('n'); + expect(infos[0]!.scope).toBe('module'); + }); }); // --------------------------------------------------------------------------- @@ -724,3 +770,159 @@ describe('VariableExtractor — block-scoped declarations', () => { expect(info).toBeNull(); }); }); + +// --------------------------------------------------------------------------- +// Dart config — F29: top-level variable declarations +// +// Top-level Dart vars are loose siblings under `program` (no `declaration` +// wrapper). The structure query captures the container node +// (initialized_identifier_list / static_final_declaration_list) as +// @definition.variable, so the extractor is fed that container. The previous +// config read a `type_identifier` that does not exist as a direct child of the +// captured node — a dead read. These tests feed the real captured container. +// --------------------------------------------------------------------------- + +describe('VariableExtractor — Dart (F29 top-level)', () => { + const extractor = createVariableExtractor(dartVariableConfig); + const ctx: VariableExtractorContext = { + filePath: 'test.dart', + language: SupportedLanguages.Dart, + }; + + /** The top-level variable container the structure query captures. */ + function captureContainer(src: string): SyntaxNode { + parser.setLanguage(Dart); + const tree = parser.parse(src); + let found: SyntaxNode | undefined; + const walk = (n: SyntaxNode) => { + if ( + (n.type === 'initialized_identifier_list' || n.type === 'static_final_declaration_list') && + n.parent?.type === 'program' + ) { + found ??= n; + } + for (let i = 0; i < n.namedChildCount; i++) { + const c = n.namedChild(i); + if (c) walk(c); + } + }; + walk(tree.rootNode); + if (!found) throw new Error('no top-level variable container found'); + return found; + } + + it('extracts a typed final top-level variable with the real type (F29)', () => { + const node = captureContainer('final int count = 3;'); + expect(extractor.isVariableDeclaration(node)).toBe(true); + const info = extractor.extract(node, ctx); + expect(info).not.toBeNull(); + expect(info!.name).toBe('count'); + expect(info!.type).toBe('int'); + expect(info!.isConst).toBe(true); + expect(info!.isMutable).toBe(false); + expect(info!.scope).toBe('module'); + }); + + it('extracts an inferred var as untyped (not from a phantom field) (F29)', () => { + const node = captureContainer("var name = 'x';"); + const info = extractor.extract(node, ctx); + expect(info).not.toBeNull(); + expect(info!.name).toBe('name'); + // `var` is inferred → no type annotation, so type is null (not a phantom). + expect(info!.type).toBeNull(); + expect(info!.isMutable).toBe(true); + expect(info!.isConst).toBe(false); + }); + + it('extracts both names from a multi-name top-level const (F29)', () => { + const node = captureContainer('const a = 1, b = 2;'); + const infos = extractor.extractAll(node, ctx); + expect(infos.map((i) => i.name).sort()).toEqual(['a', 'b']); + for (const i of infos) { + expect(i.isConst).toBe(true); + expect(i.isMutable).toBe(false); + } + }); + + it('does not let a neighbouring declaration’s type/modifier bleed in', () => { + // Three declarations under one program. The `var name` container sits after + // `final int count` — its type/modifier must NOT leak onto `name`. + parser.setLanguage(Dart); + const tree = parser.parse("final int count = 3;\nvar name = 'x';\nconst a = 1, b = 2;"); + const containers: SyntaxNode[] = []; + const walk = (n: SyntaxNode) => { + if ( + (n.type === 'initialized_identifier_list' || n.type === 'static_final_declaration_list') && + n.parent?.type === 'program' + ) { + containers.push(n); + } + for (let i = 0; i < n.namedChildCount; i++) { + const c = n.namedChild(i); + if (c) walk(c); + } + }; + walk(tree.rootNode); + + const byName = new Map[number]>(); + for (const c of containers) + for (const info of extractor.extractAll(c, ctx)) byName.set(info.name, info); + + expect(byName.get('name')!.type).toBeNull(); // not 'int' from count + expect(byName.get('name')!.isConst).toBe(false); // not final from count + expect(byName.get('count')!.type).toBe('int'); + expect(byName.get('a')!.isConst).toBe(true); + expect(byName.get('b')!.isConst).toBe(true); + }); +}); + +// --------------------------------------------------------------------------- +// Kotlin destructuring declarations (F51, issue #1919) +// --------------------------------------------------------------------------- + +const describeKotlin = Kotlin ? describe : describe.skip; + +describeKotlin('VariableExtractor — Kotlin (F51 destructuring)', () => { + const extractor = createVariableExtractor(kotlinVariableConfig); + const ctx: VariableExtractorContext = { + filePath: 'test.kt', + language: SupportedLanguages.Kotlin, + }; + + /** The first property_declaration whose text starts with `prefix`. */ + function propertyDecl(src: string, prefix: string): SyntaxNode { + parser.setLanguage(Kotlin as Parser.Language); + const tree = parser.parse(src); + let found: SyntaxNode | undefined; + const walk = (n: SyntaxNode) => { + if (n.type === 'property_declaration' && n.text.trimStart().startsWith(prefix)) { + found ??= n; + } + for (let i = 0; i < n.namedChildCount; i++) { + const c = n.namedChild(i); + if (c) walk(c); + } + }; + walk(tree.rootNode); + if (!found) throw new Error(`no property_declaration starting with ${prefix}`); + return found; + } + + it('emits one Variable per destructured name (`val (a, b) = pair`)', () => { + const node = propertyDecl('fun f() { val (a, b) = pair }', 'val (a'); + const infos = extractor.extractAll(node, ctx); + expect(infos.map((i) => i.name)).toEqual(['a', 'b']); + }); + + it('skips the `_` discard placeholder (`val (_, second) = pair`)', () => { + const node = propertyDecl('fun f() { val (_, second) = pair }', 'val (_'); + const infos = extractor.extractAll(node, ctx); + expect(infos.map((i) => i.name)).toEqual(['second']); + }); + + it('still emits exactly one name for a plain `val x = 1` (no double-count)', () => { + const node = propertyDecl('fun f() { val x = 1 }', 'val x'); + const infos = extractor.extractAll(node, ctx); + expect(infos.map((i) => i.name)).toEqual(['x']); + }); +}); From 1ca4f15267f4cef349925b2d6e492ee75699ba91 Mon Sep 17 00:00:00 2001 From: xianzuyang9-blip Date: Mon, 8 Jun 2026 15:44:05 +0800 Subject: [PATCH 3/4] fix: declare onnxruntime-common runtime dependency (#2074) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Declare onnxruntime-common runtime dependency * Declare onnxruntime-common runtime dependency * Declare onnxruntime-common runtime dependency * Declare onnxruntime-common runtime dependency * Declare onnxruntime-common runtime dependency * Remove package metadata unit test --------- Co-authored-by: Gergő Magyar --- gitnexus/package-lock.json | 1 + gitnexus/package.json | 1 + 2 files changed, 2 insertions(+) diff --git a/gitnexus/package-lock.json b/gitnexus/package-lock.json index 83534ed77..750979d80 100644 --- a/gitnexus/package-lock.json +++ b/gitnexus/package-lock.json @@ -27,6 +27,7 @@ "js-yaml": "^4.1.1", "jsonc-parser": "^3.3.1", "mnemonist": "^0.40.3", + "onnxruntime-common": "^1.26.0", "onnxruntime-node": "^1.24.0", "pandemonium": "^2.4.0", "pino": "^10.3.1", diff --git a/gitnexus/package.json b/gitnexus/package.json index 1dbb1ed80..b61a1ca96 100644 --- a/gitnexus/package.json +++ b/gitnexus/package.json @@ -71,6 +71,7 @@ "js-yaml": "^4.1.1", "jsonc-parser": "^3.3.1", "mnemonist": "^0.40.3", + "onnxruntime-common": "^1.26.0", "onnxruntime-node": "^1.24.0", "pandemonium": "^2.4.0", "pino": "^10.3.1", From 2cf7e7fa88bfa05fff76796fa401f74803977932 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gerg=C5=91=20Magyar?= Date: Mon, 8 Jun 2026 09:44:28 +0100 Subject: [PATCH 4/4] chore: release v1.6.6 (#2075) Bump gitnexus 1.6.5 -> 1.6.6 and add the 1.6.6 CHANGELOG section covering ~190 PRs merged since v1.6.5 (range v1.6.5..main). Co-authored-by: Claude Opus 4.8 (1M context) --- gitnexus/CHANGELOG.md | 65 ++++++++++++++++++++++++++++++++++++++ gitnexus/package-lock.json | 4 +-- gitnexus/package.json | 2 +- 3 files changed, 68 insertions(+), 3 deletions(-) diff --git a/gitnexus/CHANGELOG.md b/gitnexus/CHANGELOG.md index 39db0eb90..e06601f34 100644 --- a/gitnexus/CHANGELOG.md +++ b/gitnexus/CHANGELOG.md @@ -4,6 +4,71 @@ All notable changes to GitNexus will be documented in this file. ## [Unreleased] +## [1.6.6] - 2026-06-08 + +### Added + +- **Scope-resolution (RFC #909) migrations completed across the language matrix** — Rust (#1639), JavaScript (#1640), Ruby (#1831), Swift (#937, #1948), Vue SFC (#940, #1950), Dart (#939, #1970), COBOL (#941, #1835, #1842), and Kotlin (#1727, #1746, #1782) now run on the registry-primary path; Java reached 100% scope-resolution parity and joined `MIGRATED_LANGUAGES` (#1805); per-language progress reporting added to the scope-resolution phase (#1813) +- **HTTP route & consumer contract extraction (group mode)** — Spring interface routes attributed to controllers (#1743); named/positional Java Spring route args (#1834); Kotlin Spring HTTP route, consumer, and WebClient long-form extraction (#1849, #1855, #1884); Java HTTP consumer contracts (#1872); OpenFeign `@RequestLine` consumer contracts incl. plain interfaces without `@FeignClient` (#1904, #1917); FastAPI `include_router(prefix=...)` cross-file routes (#1877); indirect call patterns via FastAPI `Depends()` and frontend HTTP consumers (#1852); gRPC consumer FQN derivation from Java imports for client-jar consumers (#1889) +- **C++ overload & template resolution** — operator-call resolution (#1754), template partial ordering (#1885), user-defined conversion ranking (#1829), nullptr/ellipsis pointer conversion ranks (#1708), SFINAE filter (#1623), expanded `type_traits` constraint registry (#1648), structured resolver-suppression outcomes (#1785), function-type ADL entities (#1822), and a parameter-type class sidecar (#1642) +- **Go enhancements** — structural interface implementation inference (#1966) and a `builtInNames` set for the Go language provider (#1886) +- **Self-healing worker pool** — automatic worker replacement plus deferred-resolution observability and verbose progress logging (#1741, #1773, #1947) +- **`.gitnexusrc` config file and `gitnexus analyze --default-branch`** (#243, #1996) +- **CLI / MCP impact ergonomics** — `--uid/--file/--kind` disambiguation flags (#1907, #1914), `limit/offset/summaryOnly` pagination on the impact tool (#1818), and a per-symbol `processes` field on `byDepth` items (#1867) +- **`gitnexus analyze --repair-fts`** — enforces FTS verification with hardened repair safeguards (#1720) +- **Web viewer** — Tree View and Circles View (#1799), GitLab repository URLs (#1565), `GITNEXUS_BACKEND_URL` env var for Docker deployments (#1286), and web + CLI internationalization (#1748) +- **Wiki** — local Claude/Codex providers (#1769), an opencode local provider (#2039), and `gitnexus wiki --lang ` for multilanguage wiki generation (#1613) +- **`detect-changes` git-worktree support** (#1654) +- **DeepSeek V4 API support** (#1594) +- **Devcontainer for the Claude / Codex / Cursor CLIs** (#1875) and antigravity integration setup + hook adapter (#1730) +- **Object-literal methods linked to exported bindings** (#1718) +- **`eval-server --host`** for a user-configured bind IP (#1667) +- **PR reviewer swarm agents** (#1851) +- **tree-sitter node-type/field validation gate** — validates against the grammar and removes dead literal handling (#1937) + +### Fixed + +- **Parsing-layer coverage gaps closed across the language matrix** (umbrella #1919) — remaining open gaps (#2072) plus Java F35/F38/F41 (#1928, #2045), PHP F53/F54/F55 (#1931, #1989), COBOL F17–F23 (#1925, #1959), Rust F66/F68/F71/F72 (#1934, #1974), Python F57/F58/F61 (#1932, #1964), JS/TS F44/F83/F85/F86/F87 (#1929, #1968), and Ruby F62 (#1933, #1972) +- **Fully-qualified nested-type identity for C++ and Ruby** — distinct nodes for union-, anonymous-namespace-, and same-tail-nested types (#1978, #1981, #2004, #2005); cross-namespace same-tail inheritance bases resolved (#1993, #2005); Ruby same-tail nested mixin modules qualified with `IMPLEMENTS` routed by scope (#1991, #2006); shared codec for `__heritage__`/`__property__` markers (#1994, #2007); graph nodes materialized for scoped class/module/impl declarations (#1975, #1977); generic Rust inherent-impl methods owned through the mod-qualified `Impl` node (#1992, #2003) +- **C# resolution & memory** — global-namespace `typeBindings` O(files²) OOM eliminated (#1871, #1954) and namespace-siblings OOM with worker-path re-parse removed (#1905); qualified/alias constructor names, `:base`/`:this` initializers, and generic type-arg stripping (#2046); primary-base receiver type normalization (#2036); spurious `IMPORTS` edges from ungated `using` resolution stopped (#1881, #1908) +- **C++ dependent-base and member lookup** — resolution across nested/inline namespaces (#1634, #1814), base-specifier qualifier threading (#1815, #1819), call-site types threaded into qualified member lookup (#1632, #1810), variadic pack dependent lookup (#1909), uninitialized multi-declarators (#1965), and typedef-enum / anonymous-struct declarations (#1941) +- **Kotlin type resolution** — smart-cast refinement for `when/is` and `if/is` (#1758, #1774), overload target-id by parameter types (#1761, #1777), cross-file iterable return propagation (#1759, #1775), method-chain fixpoint receiver types (#1760, #1776), virtual dispatch via constructor type override (#1762, #1778), interface default-method dispatch via implements-split MRO (#1763, #1779), and default-parameter arity detection (#2034) +- **Go declarations** — multi-name declaration capture (#2032), fixed-array parameter binding normalization (#1988), and generic composite-literal constructor inference F33 (#1976) +- **Rust / PHP / Vue / Java parsing** — Rust `struct_expression` name pattern split (#2051); PHP import decomposition, namespace-less `.phtml` module scopes, and Blade-template exclusion (#1801, #1790, #1989); Vue JSDoc, dual-script merge, and lang plumbing F89/F90/F92 (#1936, #2050); Java inherited `RequestMapping` prefix deduplication (#2057) and same-module type resolution for duplicate FQNs (#1712) +- **TypeScript** — HOC pattern false positives fixed with `export default` HOC support (#1943) and suffix-index reuse in the scope resolver (#1840) +- **Inheritance on the worker path** — all languages' inheritance migrated to scope-resolution in worker mode (#1951, #1956); centralized heritage supertype matching (#1921, #1922, #1940); `File->Member` `DEFINES` edges skipped for class members (#1949); phantom `Function` defs for array-method callbacks no longer emitted (#1906) +- **MCP** — sibling-clone repo-ID collisions prevented and generated MCP tool names corrected (#2067); orphan processes avoided by handling stdin close/end and the startup race (#2049); duplicate-name repo resolution disambiguated for worktrees (#1753); Windows setup fallback when global `gitnexus` resolves to a non-spawnable shim (#1694) +- **Worker pool** — resilient zero-copy ingestion worker pool prevents analyze hangs on TS-root-scale loads (#1693); cache-hit native workers no longer abort (#1751, #1833); worker-pool docs drift corrected and worker-side stack surfaced on crash (#2068, #2070) +- **LadybugDB** — FTS loaded in the Windows read pool (#2040) and probed-then-loaded on Windows (#1690, #1692); non-ASCII KuzuDB paths resolved on Windows (#1811, #1817); WAL corruption detected in schema init with recovery surfaced (#1647, #1650); WAL checkpoint-threshold control (#1772); init lock skipped for read-only opens (#1783, #1784); `serve` kept stable when sidecars are missing (#1747) +- **Server / API** — `gitnexus serve` startup restored under Express 5 (#1749); `/api/graph`, `/api/search`, `/api/grep` opened read-only (#1686); native read-only enforcement and prepared statements for Cypher query paths (#1655); `eval-server` localhost binding left to the OS (#1722) +- **Embeddings** — local ONNX runtime guarded on macOS Intel before the transformers.js import (#1987) +- **Web agent** — Nexus AI agent system prompt aligned with registered tools (#1984) and the agent stopped cleanly on user Stop (#1820) +- **Group / contracts** — HTTP graph and source contracts unioned (#1709); `httpx` `AsyncClient` alias imports detected (#1687); Node gRPC `loadPackageDefinition` gate no longer matches every member call (#1916); manifest/workspace extraction moved before `closeLbug` (#1802, #1807) +- **Hooks / install** — `gitnexus` resolved on `PATH` via a pure-Node, all-OS scan (#1938, #1980); offline-first extension installs (#1161); actionable error and docs for the `pnpm dlx`/`pnpx` native-load crash (#307, #1967); `onnxruntime-common` declared as a runtime dependency (#2074); vendored grammars materialized to fix Windows EPERM (#1728, #1729) +- **CLI** — missing LadybugDB native binary detected at startup with actionable guidance (#835, #1837); `--no-stats` applied to the keep-marker stats line (#1706, #1765); skipped large-file paths surfaced by default (#1659, #1661); build.js skipped when running outside the monorepo (#1795, #1816); auto-heap raised to 16 GB with tightened cross-platform OOM guidance for UE5-scale repos (#1652) +- **Wiki** — hidden 60s default timeout removed with timeout/retry flag validation and surfaced timeout errors (#1651); budget-aware grouping to prevent context overflow on large repos (#627, #1832) +- **`detect-changes`** — `resolveWorktreeCwd` guarded against overriding a separately-indexed worktree (#1691) +- **Windows reliability** — `windowsHide:true` passed to every `child_process` spawn-family call (#1794) + +### Changed + +- **Legacy resolution deletion (Ring 4)** — removed the legacy call-resolution DAG + heritage processor (RING4-1, #942, #2023), the legacy resolution-context + tiered-lookup plumbing (RING4-2, #943, #2033), and the shadow-mode parity harness (RING4-3, #944, #2071) +- **CONTRIBUTING** — clarified local development setup (#2024) +- **Tests / CI** — cli-e2e made read-only and eval-server tests hardened under load (#2000, #1786, #1838, #1688); parity shards consolidated and the cross-platform matrix narrowed (#1798); devcontainer smoke build hardened against Docker Hub flakes (#1969); gitleaks stabilized (#2027) + +### Performance + +- **Linux-kernel-scale analysis overhaul** — worker-pool parse, finalize O(n²), and the scope-resolution memory wall (#1983, #2038) +- **Scope-capture linearized across all languages (O(n²)→O(n))** plus Python import-resolution linearization (#1918), the Go-specific re-walk fix (#1848, #1915), and owner-keyed lookup for Step 2 member resolution (#1657) +- **C++ ADL candidates indexed once instead of per-site rescans** (#1990) +- **Inert local value symbols pruned** during ingestion (#2065) + +### Chore / Dependencies + +- `@ladybugdb/core` bump in /gitnexus (#2056) +- Routine dependency bumps across /gitnexus, /gitnexus-web, /eval, and GitHub Actions — incl. `hono`, `vitest`, `@vitest/coverage-v8`, `tsx`, `lru-cache`, `express`/`@types/express`, `express-rate-limit`, `qs`, `node-addon-api`, `brace-expansion`, `langchain`, `i18next`, `dompurify`, `lucide-react`, `axios`, `zod`, `@langchain/langgraph`, `@vercel/node`, `langsmith`, `aiohttp`, `idna`, and the `docker/*` / `github/codeql-action` / `release-drafter` / `dependency-review-action` actions (#2056, #2044, #2043, #2042, #2016, #2015, #2013, #2012, #2011, #2010, #2009, #2008, #2018, #2019, #2017, #2020, #1986, #1911, #1864, #1863, #1861, #1860, #1866, #1844, #1845, #1826, #1825, #1824, #1791, #1789, #1768, #1767, #1739, #1740, #1738, #1736, #1735, #1734, #1731, #1713, #1698, #1697, #1696, #1689, #1604, #1552, #1464, #872) +- **Security** — `@vercel/node` upgraded in /gitnexus-web with transitive advisories remediated (#1705) + ## [1.6.5] - 2026-05-16 ### Added diff --git a/gitnexus/package-lock.json b/gitnexus/package-lock.json index 750979d80..c5f4aa7af 100644 --- a/gitnexus/package-lock.json +++ b/gitnexus/package-lock.json @@ -1,12 +1,12 @@ { "name": "gitnexus", - "version": "1.6.5", + "version": "1.6.6", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "gitnexus", - "version": "1.6.5", + "version": "1.6.6", "hasInstallScript": true, "license": "PolyForm-Noncommercial-1.0.0", "dependencies": { diff --git a/gitnexus/package.json b/gitnexus/package.json index b61a1ca96..cd065cef0 100644 --- a/gitnexus/package.json +++ b/gitnexus/package.json @@ -1,6 +1,6 @@ { "name": "gitnexus", - "version": "1.6.5", + "version": "1.6.6", "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.", "author": "Abhigyan Patwari", "license": "PolyForm-Noncommercial-1.0.0",