codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/README.md

@@ -30,7 +30,7 @@ See `CHANGELOG.md` for version history.
 
 ## Requirements
 
-- Node.js 18+
+- Node.js `^22.13.0` or `>=23.5.0`
 - PostgreSQL 15+ with pgvector (the symbol index's unique index relies on `NULLS NOT DISTINCT`, added in PostgreSQL 15); pgvector ≥ 0.8 recommended (filtered search on large projects; older versions work with reduced recall)
 - Docker (for local DB + Infinity) — or bring your own PostgreSQL with pgvector + an embedding backend (see [Embedding providers](#embedding-providers))
 
@@ -48,7 +48,8 @@ rag-setup
 
 Walks you through:
 - **Database** — enter connection details; optionally starts Docker containers automatically
-- **Embedding backend** — pick a provider (`infinity` / `openai-compatible` / `voyage`), its model, and an API key if the provider needs one (see [Embedding providers](#embedding-providers))
+- **Embedding backend** — pick a provider (`infinity` / `openai-compatible` / `voyage`), its model, and an API key if the provider needs one (see [Embedding providers](#embedding-providers)), then a reranker
+  - **`voyage`** is a short path: the API key comes first and is required (stored once in `.env` as `VOYAGE_API_KEY`); no base URL is asked. The embedding model is picked from a numbered list (`voyage-code-4` default, `voyage-4-large`, `voyage-4`, `voyage-4-lite`) — enter a number, press Enter for the default, or type any model name. Then `Enable Voyage reranker? (y/n) (y)`: `y` picks `rerank-3` (default) or `rerank-3-lite` the same way and reuses the same key (`reranker.apiKey: env:VOYAGE_API_KEY`); `n` turns reranking off. Other rerankers for a Voyage embedder (an `openai-compatible` `/rerank` server, a separate Voyage key) are set with `rag-config` — see [Reranker with a cloud embedder](#reranker-with-a-cloud-or-external-embedder)
 - **Logging** — choose log level and directory (defaults: `error` level, `~/.config/codesearch-mcp/logs/`)
 
 Config is saved to `~/.config/codesearch-mcp/config.json`.
@@ -76,15 +77,28 @@ rag-index --select --reindex
 rag-index --project billing-service           # scope this run to one project, by exact name
 rag-index --reindex --project billing-service # force a full reindex of just that project
 rag-index --project                           # no name — pick one from an interactive prompt
+rag-index --project billing-service --require-cwd # refuse the run unless the current directory is that project's directory
 ```
 
 `--project` leaves every other indexed project untouched: it skips the `.ragprojects`/`.ragskip` selector entirely and never prunes projects outside the one(s) it resolves to. A name that doesn't match any discovered project or monorepo unit exits with an error before touching the database — matching exactly, no partial or fuzzy match.
 
+`--require-cwd` is for scripts that must not read another checkout's index by accident: run from a linked worktree, a second clone, or a subdirectory of the project, `rag-index` prints both directories and exits 1 before any database or embedding work. It needs `--project <name>`; without a name it is a usage error, never a prompt. Directories are compared by real path, against the unit's directory when a unit name matched, else the leaf project's, and a relative `workspaceRoot` is refused. In a root-level Nx workspace with no discovered project at its root, no `--project` name matches that root, so `--require-cwd` refuses every run from there.
+
+### Exit codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | No file failed and nothing else failed. This includes an interrupted run, which may have left files unindexed. |
+| `2` | The run finished with failed files and the rest of the index is usable. `Indexing finished with <n> of <total> file(s) failed.` is on stderr, and the next run retries those files. |
+| `1` | Any other failure, including failed files in a run that was interrupted, skipped no file and stored no chunks, failed to prune, or ended with the database or the embedding backend unavailable (`Indexing backend unavailable: <cause>`). |
+
+A failed file does not stop the run: the summary is still printed, and unless the run is interrupted the remaining files and projects are still indexed and the project graph is still produced.
+
 ## Monorepo support
 
 If `workspaceRoot` is an [Nx](https://nx.dev) workspace (detected by `nx.json`), `rag-index` discovers each project under `apps/`, `libs/`, and `packages/` as a **separate indexed project** rather than scanning the workspace as one blob. Cross-project imports like `@scope/shared` resolve through the workspace `tsconfig.base.json` path aliases, so `get_dependencies` / `get_dependents` report edges **across** projects.
 
-**Nested Nx repos.** `workspaceRoot` may also be a plain directory that *contains* an Nx repo in one of its immediate subdirectories (alongside ordinary projects). That nested repo is detected and expanded into its own projects, named `<repo>/<project>` (e.g. `micros-learning/account`), each resolved with the repo's own `tsconfig.base.json`. In the project selector the whole Nx repo appears as **one** selectable entry (so `.ragprojects` stores just `micros-learning`); selecting it indexes all its sub-projects. Ordinary sibling directories are unaffected.
+**Nested Nx repos.** `workspaceRoot` may also be a plain directory that *contains* an Nx repo in one of its immediate subdirectories (alongside ordinary projects). That nested repo is detected and expanded into its own projects, named `<repo>/<project>` (e.g. `mu-monorepo/account`), each resolved with the repo's own `tsconfig.base.json`. In the project selector the whole Nx repo appears as **one** selectable entry (so `.ragprojects` stores just `mu-monorepo`); selecting it indexes all its sub-projects. Ordinary sibling directories are unaffected.
 
 No configuration needed — detection is automatic. Plain (non-Nx) workspaces keep the original behavior: each immediate subdirectory with a `package.json` is one project.
 
@@ -126,7 +140,7 @@ Add `.ragmeta.json` to a project root to enrich `list_projects` and generate a v
   "stack": "NestJS, GraphQL, PostgreSQL",
   "notes": "Uses optimistic locking — see order-service/docs/concurrency.md",
   "relations": {
-    "consumed_by": ["crm-frontend"],
+    "consumed_by": ["beta-frontend"],
     "consumes": ["billing-service", "auth-service"]
   }
 }
@@ -143,7 +157,7 @@ Pass `include_graph_context: true` to `search_codebase` to see direct imports an
 **Symbol:** InvoiceService.create
 **Line:** 45
 ...code...
-**Relevance:** 0.32
+**Distance:** 0.32
 **Imports:** src/repositories/InvoiceRepo.ts · src/dto/CreateInvoiceDto.ts
 **Used by:** src/controllers/InvoiceController.ts
 ```
@@ -210,13 +224,13 @@ rag-config edit                      # open config in $EDITOR; validates on save
 | `embedding.model` | `jinaai/jina-embeddings-v2-base-code` | Embedding model |
 | `embedding.dimensions` | (derived) | Vector width override; required for models whose native width exceeds 2000 (Matryoshka). Otherwise derived from model → registry → runtime probe |
 | `embedding.batchSize` | `32` | Texts per batch embedding request |
-| `search.similarityThreshold` | `0.6` | Max cosine distance — raise if search returns nothing |
+| `search.similarityThreshold` | per model | Max cosine distance, lower = stricter. Auto per model unless set: the recommended value of `embedding.model` (`0.95` for `voyage-code-4`, `voyage-4`, `voyage-4-large` and `voyage-4-lite`, `0.6` for `jinaai/jina-embeddings-v2-base-code`), `1.0` for a model with none. An explicit value more than `0.1` from the recommendation produces a warning in the MCP server instructions and the log, and on the eval console |
 | `reranker.enabled` | context | Enable cross-encoder reranking. When absent: on with `infinity` embedding or when the `reranker` block names a server (`provider`/`baseURL`/`url`), off otherwise |
 | `reranker.provider` | `openai-compatible` | Rerank backend — `openai-compatible` `/rerank` (Infinity, vLLM) or `voyage` (Voyage AI, needs `reranker.apiKey`) |
 | `reranker.baseURL` | per-provider | Rerank server base URL — `embedding.baseURL` for `openai-compatible` (Infinity serves embed + rerank from one server), `https://api.voyageai.com/v1` for `voyage` |
 | `reranker.model` | per-provider | Reranker model name — `mixedbread-ai/mxbai-rerank-xsmall-v1` for `openai-compatible`, `rerank-3` for `voyage` |
-| `reranker.overfetch` | `5` | Candidate multiplier before reranking (`limit × N`) |
-| `reranker.candidateFloor` | `80` | Minimum candidate pool fed to the reranker regardless of `limit` — `fetchLimit = min(max(limit × overfetch, candidateFloor), 200)`. Raise on GPU/fast hosts for better recall; lower on weak CPU to cut latency |
+| `reranker.overfetch` | `5` | Candidate multiplier before reranking (`limit × N`); also sizes the pool of a search without reranking whose `per_file` is below `limit` |
+| `reranker.candidateFloor` | `80` | Minimum candidate pool fed to the reranker regardless of `limit` — `fetchLimit = min(max(limit × overfetch, candidateFloor), 200)`. The same pool serves a search without reranking whose `per_file` is below `limit`. Raise on GPU/fast hosts for better recall; lower on weak CPU to cut latency |
 | `indexing.chunkSize` | `1500` | Max characters per chunk |
 | `indexing.chunkOverlap` | `200` | Overlap between chunks |
 | `indexing.embedBatchSize` | `5` | Parallel embedding requests per batch |
@@ -296,11 +310,11 @@ The same "already running?" probe applies everywhere: a reachable backend defaul
 
 ### Reranker with a cloud or external embedder
 
-With a cloud embedder (OpenAI, Voyage, Azure) and no `reranker` block, reranking is **off** — those endpoints don't serve `/rerank`. `rag-setup` asks for a reranker after the embedding step for every provider (`voyage`, `openai-compatible`, `none`, plus `infinity` for an Infinity embedder) and always writes an explicit `reranker` block. To configure one by hand:
+With a cloud embedder (OpenAI, Voyage, Azure) and no `reranker` block, reranking is **off** — those endpoints don't serve `/rerank`. `rag-setup` configures a reranker after the embedding step for every provider and always writes an explicit `reranker` block: a Voyage embedder gets one question, `Enable Voyage reranker?`, and shares its `VOYAGE_API_KEY`; other embedders choose `voyage` (own key, `VOYAGE_RERANK_API_KEY`), `openai-compatible` or `none`, plus `infinity` for an Infinity embedder. To configure one by hand:
 
-These recipes edit whatever `reranker` block is already stored, so each one sets `reranker.enabled true` (an explicit `false` from `rag-setup`'s `none` choice would otherwise win) and clears the keys that would point the requests at the old server.
+These recipes edit whatever `reranker` block is already stored, so each one sets `reranker.enabled true` (an explicit `false` from `rag-setup`'s `none` choice, or the `n` answer to a Voyage embedder's `Enable Voyage reranker?`, would otherwise win) and clears the keys that would point the requests at the old server.
 
-**Voyage reranker** (works with any embedder; its key is separate from the embedding key):
+**Voyage reranker** (works with any embedder; with a Voyage embedder `reranker.apiKey` can point at the same `env:VOYAGE_API_KEY` instead of a separate key):
 
 ```bash
 echo 'VOYAGE_RERANK_API_KEY=pa-…' >> ~/.config/codesearch-mcp/.env
@@ -338,7 +352,7 @@ Switching the embedding model, provider, or dimension is applied by **re-indexin
 When reranking is enabled, `search_codebase` fetches a **candidate pool** by cosine distance, reranks it with the cross-encoder, and returns the top `limit`. Three knobs and one relationship govern how good the results are and how long they take:
 
 - **Pool size** — `fetchLimit = min(max(limit × overfetch, candidateFloor), 200)`. `candidateFloor` (default `80`) guarantees the reranker a large enough menu even at the default `limit = 5`; without it a small `limit` starves the reranker (only `5 × 5 = 25` candidates) and its best matches never enter the window.
-- **Threshold ↔ window** — raising `search.similarityThreshold` lets *more* chunks under the bar, so the pool must be wide enough to reach them; a strict threshold with a small pool silently truncates recall. Widen `candidateFloor`/`overfetch` when you raise the threshold.
+- **Threshold ↔ window** — distance scales differ per embedding model, so an unset `search.similarityThreshold` follows the model. Raising the threshold lets *more* chunks under the bar, so the pool must be wide enough to reach them; when more chunks are under the threshold than the window takes, recall is silently truncated. Widen `candidateFloor`/`overfetch` when you raise the threshold.
 - **Latency** — the reranker cost grows with pool size (on CPU, tens of seconds; a rough guide is a large fixed cost plus a per-candidate increment). Bigger pool = better recall, slower query. GPU/fast hosts can raise `candidateFloor`; ultra-constrained hosts lower it.
 
 The pool is reachable on large projects too. The HNSW index scan stops after `hnsw.ef_search` rows (PostgreSQL default 40) and only then applies the `project` filter and the threshold, so a scoped search on a project of a few thousand chunks or more (measured from ~5.8 k; the crossover depends on table statistics) — or an unscoped one — used to get at most 40 candidates, often far fewer. Each search now sets `hnsw.ef_search` to the requested row count (at least 40, at most 1000) and, on pgvector ≥ 0.8, `hnsw.iterative_scan = relaxed_order` for its own query, so `candidateFloor` / `overfetch` size the pool the reranker actually receives, unless the iterative scan stops at `hnsw.max_scan_tuples` (20 000) first. On an older pgvector only `ef_search` is raised, and one `warn` line per process names the version — or `unknown` if the first version read failed, with no later line naming it. Like the Voyage warning above, it is visible only at `logging.level` `warn` or lower.
@@ -351,7 +365,7 @@ rag-config set logging.level info
 
 Each search then writes one `search metrics` line with, among others: `fetchLimit`, `candidatesReturned`, `poolSaturated`, `maxCosineRankSurvived`, `distinctFilesInResult`, `topFileShare`, `efSearch`/`iterativeScan` (the HNSW settings sent with the query), and `embedMs`/`rerankMs`/`dbMs`/`totalMs`. Read them as:
 
-- **`poolSaturated: true`** — more chunks were under the threshold than the window took → recall is being truncated; raise `candidateFloor`/`overfetch`.
+- **`poolSaturated: true`** — more chunks were under the threshold than the window took → recall is being truncated; raise `candidateFloor`/`overfetch`. Under the `1.0` fallback (a model with no recommended value) nearly every chunk is under the threshold, so in a scope holding more chunks than the window this stays true at any pool size, and every search that reranks sends the full pool to the reranker; set `search.similarityThreshold` instead of widening the pool.
 - **`maxCosineRankSurvived`** — the deepest cosine rank that survived reranking. If it stays well below `fetchLimit`, the pool is bigger than needed → shrink it to save latency; if it approaches `fetchLimit`, widen.
 
 ## Index consistency
@@ -369,13 +383,13 @@ A failure pruning one project does not block the others or stop indexing of the
 
 ## Architecture
 
-**Stack:** TypeScript on Node.js 18+ · PostgreSQL 17 + pgvector (HNSW, cosine distance) via Drizzle ORM · ts-morph for AST/symbol/call-graph extraction · `@langchain/textsplitters` for chunk fallback · MCP SDK over stdio · Zod v4 for config validation and JSON-Schema generation · pino + pino-roll for logging · plain `node:http` dashboard with vis-network · Vitest · Docker Compose for Postgres + Infinity.
+**Stack:** TypeScript on Node.js 22.13+ · PostgreSQL 17 + pgvector (HNSW, cosine distance) via Drizzle ORM · ts-morph for AST/symbol/call-graph extraction · `@langchain/textsplitters` for chunk fallback · MCP SDK over stdio · Zod v4 for config validation and JSON-Schema generation · pino + pino-roll for logging · plain `node:http` dashboard with vis-network · Vitest · Docker Compose for Postgres + Infinity.
 
 **Design:**
 - **Composition root + manual DI** — `src/container.ts` builds every service once and wires it through constructors; no module-level singletons, no DI framework.
-- **Dependency inversion** — services depend on interfaces (`IEmbedder`, `IDatabase`, `IAstParser`, `IChunker`, `ISearcher`, `IProjectDiscovery`, `IMonorepoResolver`, `IMcpToolHandler`), so providers (OpenAI-compatible/Voyage/Infinity — Ollama via `openai-compatible`), chunking strategy (`ast`/`character`), and monorepo resolvers are swappable.
+- **Dependency inversion** — services depend on interfaces (`IEmbedder`, `IDatabase`, `IAstParser`, `IChunker`, the role interfaces of the search and path parts (`IChunkSearch`, `IToolPaths`, `ISymbolLookup`, …), `IProjectDiscovery`, `IMonorepoResolver`, `IMcpToolHandler`), so providers (OpenAI-compatible/Voyage/Infinity — Ollama via `openai-compatible`), chunking strategy (`ast`/`character`), and monorepo resolvers are swappable.
 - **Command pattern** — each CLI mode (`rag-index`, `rag-mcp`, `rag-config`, `rag-web`) is its own `ICommand`; `app.ts` only dispatches.
-- **Registry / Open-Closed** — MCP tools are `IMcpToolHandler` implementations registered in a `Map`; adding a tool never touches `McpServer`.
+- **Registry / Open-Closed** — MCP tools extend `McpTool`, which implements `IMcpToolHandler`, and are registered in a `Map` by `McpServer.createTools()`; adding a tool means extending `McpTool` and registering it there, and the dispatch logic never changes.
 - **Fallback chains** — vector dimension: config override → model registry → runtime probe; `find_symbol`/`get_dependents`: indexed table → grep; failed rerank → vector order.
 - **Incremental indexing** — mtime fast path, SHA-256 fallback for clones/transfers, AST-aligned chunk boundaries so declarations aren't split arbitrarily.
 - **Index/model consistency guard** — `index_meta` tracks the embedding model that built the index; search refuses with a clear re-index message on mismatch instead of returning noise.
@@ -384,4 +398,6 @@ Full internals (per-file responsibilities, every pattern with file:line referenc
 
 ## License
 
-MIT
+Copyright (C) 2026 Oleksandr Antoniuk.
+
+Licensed under the [GNU Affero General Public License v3.0 only](LICENSE) (`AGPL-3.0-only`). Versions up to and including `0.3.0-alpha` were released under the MIT License and remain available under it.

package/dist/app.js

@@ -37,6 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const help_1 = require("./src/help");
+const index_args_1 = require("./src/index-args");
 const container_1 = require("./src/container");
 const config_1 = require("./src/config");
 const config_store_1 = require("./src/config-store");
@@ -110,25 +111,17 @@ async function main() {
         }
     }
     else if (mode === 'index') {
-        const boolFlags = new Set(['--reindex', '--select']);
-        const unknown = [];
-        for (let i = 0; i < effectiveArgs.length; i++) {
-            const a = effectiveArgs[i];
-            if (boolFlags.has(a))
-                continue;
-            if (a === '--project') {
-                const next = effectiveArgs[i + 1];
-                if (next !== undefined && !next.startsWith('-'))
-                    i++;
-                continue;
-            }
-            unknown.push(a);
-        }
-        if (unknown.length > 0) {
-            console.error(`Unexpected argument: ${unknown[0]}\n`);
+        const unexpected = (0, index_args_1.findUnexpectedIndexArg)(effectiveArgs);
+        if (unexpected !== undefined) {
+            console.error(`Unexpected argument: ${unexpected}\n`);
             (0, help_1.printHelp)(isBinary ? argv1 : 'rag-index');
             process.exit(1);
         }
+        const cwdCause = (0, index_args_1.unreadableCwdCause)(effectiveArgs);
+        if (cwdCause !== undefined) {
+            console.error(`\n${cwdCause}`);
+            process.exit(1);
+        }
     }
     else if (mode === 'mcp' || mode === 'setup') {
         if (effectiveArgs.length > 0) {
@@ -183,10 +176,10 @@ async function main() {
         process.exit(1);
     }
     const factories = {
-        index: () => new IndexCommand_1.IndexCommand(container, argv1),
-        eval: () => new EvalCommand_1.EvalCommand(container, argv1),
-        mcp: () => new McpCommand_1.McpCommand(container),
-        web: () => new WebCommand_1.WebCommand(container, effectiveArgs),
+        index: () => new IndexCommand_1.IndexCommand(container.db, container.embedder, container.indexer, container.search.dependencies, container.discovery, container.config, argv1),
+        eval: () => new EvalCommand_1.EvalCommand(container.db, container.search.chunks, container.search.catalog, container.config, argv1),
+        mcp: () => new McpCommand_1.McpCommand(container.readiness, container.mcp, container.logger),
+        web: () => new WebCommand_1.WebCommand(container.db, container.embedder, container.search.catalog, container.search.dependencies, container.config, container.logger, effectiveArgs),
     };
     const factory = factories[mode];
     if (!factory) {

package/dist/src/ast/CallExtractor.d.ts

@@ -0,0 +1,8 @@
+import { type SourceFile } from 'ts-morph';
+import type { CallEdge } from '../interfaces/IAstParser';
+import type { IIndexedNodeResolver } from '../interfaces';
+export declare class CallExtractor {
+    private readonly resolver;
+    constructor(resolver: IIndexedNodeResolver);
+    extractCalls(sourceFile: SourceFile, filePath: string, serviceName: string): CallEdge[];
+}

package/dist/src/ast/CallExtractor.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallExtractor = void 0;
+const ts_morph_1 = require("ts-morph");
+class CallExtractor {
+    resolver;
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    extractCalls(sourceFile, filePath, serviceName) {
+        const calls = [];
+        for (const callExpr of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)) {
+            const expr = callExpr.getExpression();
+            let calleeName = null;
+            let calleeFile = null;
+            let calleeDecl;
+            try {
+                if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+                    calleeName = expr.getName();
+                    const sym = expr.getNameNode().getSymbol();
+                    const decl = sym?.getDeclarations()?.[0];
+                    const declPath = decl?.getSourceFile().getFilePath();
+                    if (declPath && !declPath.includes('/node_modules/')) {
+                        calleeFile = declPath;
+                        calleeDecl = decl;
+                    }
+                }
+                else if (ts_morph_1.Node.isIdentifier(expr)) {
+                    calleeName = expr.getText();
+                    const sym = expr.getSymbol();
+                    if (sym) {
+                        const firstDecl = sym.getDeclarations()?.[0];
+                        const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl)
+                            ? (sym.getAliasedSymbol() ?? sym)
+                            : sym;
+                        const decl = resolved.getDeclarations()?.[0];
+                        const declPath = decl?.getSourceFile().getFilePath();
+                        if (declPath && !declPath.includes('/node_modules/')) {
+                            calleeFile = declPath;
+                            calleeDecl = decl;
+                        }
+                    }
+                }
+            }
+            catch {
+            }
+            if (!calleeName || !calleeFile)
+                continue;
+            const described = calleeDecl ? this.resolver.describeIndexedNode(calleeDecl) : null;
+            const calleeSymbol = described ? this.resolver.qualifiedName(described) : null;
+            const fromSymbol = this.resolver.findFromSymbol(callExpr);
+            const pos = sourceFile.compilerNode
+                .getLineAndCharacterOfPosition(callExpr.getStart());
+            calls.push({
+                project: serviceName,
+                fromFile: filePath,
+                fromSymbol,
+                calleeName,
+                calleeFile,
+                calleeSymbol,
+                line: pos.line + 1,
+                col: pos.character + 1,
+            });
+        }
+        return calls;
+    }
+}
+exports.CallExtractor = CallExtractor;

package/dist/src/ast/GraphqlNameExtractor.d.ts

@@ -0,0 +1,22 @@
+import { type SourceFile } from 'ts-morph';
+import type { SymbolEntry } from '../interfaces/IAstParser';
+import type { ILogger, IIndexedNodeResolver } from '../interfaces';
+import type { DeclarationCandidate } from '../declarations/DeclarationTreeBuilder';
+import { type ResolveDeclaration } from './node-helpers';
+export declare class GraphqlNameExtractor {
+    private readonly resolver;
+    private readonly logger;
+    private readonly resolveDeclaration;
+    constructor(resolver: IIndexedNodeResolver, logger: ILogger, resolveDeclaration?: ResolveDeclaration);
+    private buildGraphqlImportMap;
+    private recognizedDecorator;
+    private deriveGraphqlName;
+    private logGraphqlSkip;
+    private declarationNameFor;
+    private classGraphqlTypeName;
+    private resolveResolverParentType;
+    private extractClassTypeRows;
+    private extractResolveFieldRow;
+    private extractMethodOperationRows;
+    extractGraphqlNames(sourceFile: SourceFile, filePath: string, serviceName: string, ownRows: DeclarationCandidate[]): SymbolEntry[];
+}

package/dist/src/ast/GraphqlNameExtractor.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphqlNameExtractor = void 0;
+const ts_morph_1 = require("ts-morph");
+const node_helpers_1 = require("./node-helpers");
+const graphql_grammar_1 = require("./graphql-grammar");
+class GraphqlNameExtractor {
+    resolver;
+    logger;
+    resolveDeclaration;
+    constructor(resolver, logger, resolveDeclaration = node_helpers_1.defaultResolveDeclaration) {
+        this.resolver = resolver;
+        this.logger = logger;
+        this.resolveDeclaration = resolveDeclaration;
+    }
+    buildGraphqlImportMap(sourceFile) {
+        const map = new Map();
+        for (const decl of sourceFile.getImportDeclarations()) {
+            if (decl.getModuleSpecifierValue() !== graphql_grammar_1.GRAPHQL_MODULE)
+                continue;
+            for (const named of decl.getNamedImports()) {
+                const exportedName = named.getName();
+                const localName = named.getAliasNode()?.getText() ?? exportedName;
+                map.set(localName, exportedName);
+            }
+        }
+        return map;
+    }
+    recognizedDecorator(dec, importMap) {
+        const idNode = (0, graphql_grammar_1.decoratorIdentifier)(dec);
+        if (!idNode)
+            return null;
+        const exported = importMap.get(idNode.getText());
+        if (!exported)
+            return null;
+        const expr = dec.getExpression();
+        const args = ts_morph_1.Node.isCallExpression(expr) ? expr.getArguments() : [];
+        return { name: exported, args };
+    }
+    deriveGraphqlName(args, allowOptionsName, fallbackName) {
+        if (args.length > 0) {
+            const first = args[0];
+            const { inner, wrapped } = (0, graphql_grammar_1.peekThroughWrapper)(first);
+            const literal = (0, graphql_grammar_1.literalStringValue)(inner);
+            if (literal !== null) {
+                if (wrapped)
+                    return { ok: false, reason: 'non-literal-name' };
+                return (0, graphql_grammar_1.checkGraphqlGrammar)(literal);
+            }
+            const isTypeFnOrOptions = ts_morph_1.Node.isArrowFunction(inner) || ts_morph_1.Node.isFunctionExpression(inner) || ts_morph_1.Node.isObjectLiteralExpression(inner);
+            if (!isTypeFnOrOptions)
+                return { ok: false, reason: 'non-literal-name' };
+        }
+        if (allowOptionsName) {
+            for (const arg of args) {
+                const { inner, wrapped } = (0, graphql_grammar_1.peekThroughWrapper)(arg);
+                if (!ts_morph_1.Node.isObjectLiteralExpression(inner))
+                    continue;
+                if (wrapped)
+                    return { ok: false, reason: 'non-literal-name' };
+                const nameProp = (0, graphql_grammar_1.findNameProperty)(inner);
+                if (!nameProp)
+                    continue;
+                if (ts_morph_1.Node.isShorthandPropertyAssignment(nameProp))
+                    return { ok: false, reason: 'non-literal-name' };
+                const init = nameProp.getInitializer();
+                const value = init ? (0, graphql_grammar_1.literalStringValue)(init) : null;
+                if (value !== null)
+                    return (0, graphql_grammar_1.checkGraphqlGrammar)(value);
+                return { ok: false, reason: 'non-literal-name' };
+            }
+        }
+        return (0, graphql_grammar_1.checkGraphqlGrammar)(fallbackName);
+    }
+    logGraphqlSkip(filePath, declaration, decorator, reason, value) {
+        const fields = { filePath, declaration, decorator, reason };
+        if (value !== undefined)
+            fields.value = value;
+        this.logger.debug('AstParser: graphql row skipped', fields);
+    }
+    declarationNameFor(node, fallback) {
+        const described = this.resolver.describeIndexedNode(node);
+        return described ? this.resolver.qualifiedName(described) : fallback;
+    }
+    classGraphqlTypeName(declClass) {
+        const declImportMap = this.buildGraphqlImportMap(declClass.getSourceFile());
+        const decorators = declClass.getDecorators();
+        const hasAnyTypeSpelledDecorator = decorators.some((d) => {
+            const idNode = (0, graphql_grammar_1.decoratorIdentifier)(d);
+            const text = idNode?.getText();
+            return text === 'ObjectType' || text === 'InterfaceType';
+        });
+        const recognized = decorators
+            .map(d => this.recognizedDecorator(d, declImportMap))
+            .find(r => r?.name === 'ObjectType')
+            ?? decorators.map(d => this.recognizedDecorator(d, declImportMap)).find(r => r?.name === 'InterfaceType');
+        if (recognized) {
+            const fallbackName = declClass.getName() ?? (declClass.isDefaultExport() ? 'default' : '');
+            const nameResult = this.deriveGraphqlName(recognized.args, false, fallbackName);
+            return nameResult.ok ? { ok: true, name: nameResult.name } : { ok: false };
+        }
+        if (hasAnyTypeSpelledDecorator)
+            return { ok: false };
+        const name = declClass.getName();
+        if (!name)
+            return { ok: false };
+        return graphql_grammar_1.GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, value: name };
+    }
+    resolveResolverParentType(cls, importMap) {
+        const resolverDec = cls.getDecorators()
+            .map(d => this.recognizedDecorator(d, importMap))
+            .find(r => r?.name === 'Resolver');
+        if (!resolverDec || resolverDec.args.length === 0)
+            return { ok: false };
+        const argNode = resolverDec.args[0];
+        const literal = (0, graphql_grammar_1.literalStringValue)(argNode);
+        if (literal !== null) {
+            return graphql_grammar_1.GRAPHQL_NAME_RE.test(literal) ? { ok: true, name: literal } : { ok: false, value: literal };
+        }
+        const identifier = (0, graphql_grammar_1.extractResolverIdentifier)(argNode);
+        if (!identifier)
+            return { ok: false };
+        const resolve = this.resolveDeclaration;
+        const declaration = resolve(identifier);
+        if (!declaration || !ts_morph_1.Node.isClassDeclaration(declaration))
+            return { ok: false };
+        return this.classGraphqlTypeName(declaration);
+    }
+    extractClassTypeRows(cls, importMap, ownByDeclNode, filePath, serviceName, entries) {
+        const own = ownByDeclNode.get(cls);
+        const declaration = this.declarationNameFor(cls, own?.entry.name ?? cls.getName() ?? 'default');
+        const seenNames = new Set();
+        for (const dec of cls.getDecorators()) {
+            const rec = this.recognizedDecorator(dec, importMap);
+            if (!rec || !graphql_grammar_1.GRAPHQL_TYPE_DECORATORS.has(rec.name))
+                continue;
+            if ((0, graphql_grammar_1.isAbstractGraphqlType)(rec.args)) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'abstract-type');
+                continue;
+            }
+            if (!own) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'no-symbol-row');
+                continue;
+            }
+            const nameResult = this.deriveGraphqlName(rec.args, false, own.entry.name);
+            if (!nameResult.ok) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
+                continue;
+            }
+            if (seenNames.has(nameResult.name)) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'duplicate', own.entry.name);
+                continue;
+            }
+            seenNames.add(nameResult.name);
+            entries.push({
+                project: serviceName, filePath, name: nameResult.name, kind: 'graphql_type',
+                signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
+                container: null, isStatic: false, target: declaration,
+            });
+        }
+    }
+    extractResolveFieldRow(method, rec, own, declaration, importMap, filePath, serviceName, entries) {
+        if (!own) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'no-symbol-row');
+            return;
+        }
+        const cls = method.getParent();
+        if (!cls || !ts_morph_1.Node.isClassDeclaration(cls)) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent');
+            return;
+        }
+        const parent = this.resolveResolverParentType(cls, importMap);
+        if (!parent.ok) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent', parent.value);
+            return;
+        }
+        const nameResult = this.deriveGraphqlName(rec.args, true, own.entry.name);
+        if (!nameResult.ok) {
+            this.logGraphqlSkip(filePath, declaration, 'ResolveField', nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
+            return;
+        }
+        entries.push({
+            project: serviceName, filePath, name: nameResult.name, kind: 'graphql_field',
+            signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
+            container: parent.name, isStatic: own.entry.isStatic, target: declaration,
+        });
+    }
+    extractMethodOperationRows(method, importMap, ownByDeclNode, filePath, serviceName, entries) {
+        const own = ownByDeclNode.get(method);
+        const declaration = this.declarationNameFor(method, own?.entry.name ?? (0, node_helpers_1.memberName)(method.getNameNode()) ?? '<anonymous>');
+        for (const dec of method.getDecorators()) {
+            const rec = this.recognizedDecorator(dec, importMap);
+            if (!rec)
+                continue;
+            if (rec.name === 'ResolveField') {
+                try {
+                    this.extractResolveFieldRow(method, rec, own, declaration, importMap, filePath, serviceName, entries);
+                }
+                catch (err) {
+                    this.logGraphqlSkip(filePath, declaration, 'ResolveField', 'unresolvable-parent');
+                }
+                continue;
+            }
+            const kind = graphql_grammar_1.GRAPHQL_OPERATION_KIND[rec.name];
+            if (!kind)
+                continue;
+            if (!own) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, 'no-symbol-row');
+                continue;
+            }
+            const nameResult = this.deriveGraphqlName(rec.args, true, own.entry.name);
+            if (!nameResult.ok) {
+                this.logGraphqlSkip(filePath, declaration, rec.name, nameResult.reason, nameResult.reason === 'invalid-name' ? nameResult.value : undefined);
+                continue;
+            }
+            entries.push({
+                project: serviceName, filePath, name: nameResult.name, kind,
+                signature: own.entry.signature, line: own.entry.line, endLine: own.entry.endLine, col: own.entry.col,
+                container: rec.name, isStatic: own.entry.isStatic, target: declaration,
+            });
+        }
+    }
+    extractGraphqlNames(sourceFile, filePath, serviceName, ownRows) {
+        const importMap = this.buildGraphqlImportMap(sourceFile);
+        if (importMap.size === 0)
+            return [];
+        const ownByDeclNode = new Map();
+        for (const c of ownRows)
+            ownByDeclNode.set(c.declNode, c);
+        const entries = [];
+        for (const cls of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ClassDeclaration)) {
+            this.extractClassTypeRows(cls, importMap, ownByDeclNode, filePath, serviceName, entries);
+        }
+        for (const method of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)) {
+            this.extractMethodOperationRows(method, importMap, ownByDeclNode, filePath, serviceName, entries);
+        }
+        return entries;
+    }
+}
+exports.GraphqlNameExtractor = GraphqlNameExtractor;

package/dist/src/ast/ImportEdgeExtractor.d.ts

@@ -0,0 +1,11 @@
+import { type SourceFile } from 'ts-morph';
+import type { DepEdge } from '../interfaces/IAstParser';
+import type { ILogger } from '../interfaces';
+export declare class ImportEdgeExtractor {
+    private readonly logger;
+    constructor(logger: ILogger);
+    extractEdges(sourceFile: SourceFile, filePath: string, serviceName: string): DepEdge[];
+    private resolveSideEffectModuleSpecifier;
+    private resolveFromSymbol;
+    private buildUsageMap;
+}