codesearch-mcp 0.2.3-alpha → 0.3.0-alpha

package/dist/src/constants.js

@@ -1,48 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FORMER_OLLAMA_MODELS = exports.DEFAULT_EMBED_MODEL = exports.MODEL_REGISTRY = exports.MAX_EMBED_DIM = void 0;
+exports.FORMER_OLLAMA_MODELS = exports.DEFAULT_EMBED_MODEL = exports.MODEL_REGISTRY = exports.MAX_EMBED_DIM = exports.VOYAGE_RERANK_MODELS = void 0;
 exports.registryDimension = registryDimension;
 exports.resolveDimension = resolveDimension;
-/**
- * pgvector's HNSW / IVFFlat index hard limit. The effective embedding dimension
- * must not exceed this; larger cloud models must reduce via the Matryoshka
- * `dimensions` request parameter (`embedding.dimensions`).
- */
+exports.VOYAGE_RERANK_MODELS = ['rerank-3', 'rerank-3-lite'];
 exports.MAX_EMBED_DIM = 2000;
-/**
- * Advisory (NOT exhaustive) registry of known embedding models. Used to resolve
- * a model's dimension without a runtime probe and to suggest models in the
- * dashboard. Models absent here still work — their dimension is probed at index
- * time (see `resolveDimension`).
- */
 exports.MODEL_REGISTRY = {
     'text-embedding-3-small': { provider: 'openai-compatible', dimensions: 1536, dimConfigurable: true },
     'text-embedding-3-large': { provider: 'openai-compatible', dimensions: 3072, dimConfigurable: true, maxIndexable: 2000 },
     'text-embedding-ada-002': { provider: 'openai-compatible', dimensions: 1536 },
-    'voyage-code-3': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
-    'voyage-3': { provider: 'voyage', dimensions: 1024, dimConfigurable: true },
-    'voyage-3-lite': { provider: 'voyage', dimensions: 512 },
+    'voyage-code-4': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
+    'voyage-4-large': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
+    'voyage-4': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
+    'voyage-4-lite': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
     'BAAI/bge-m3': { provider: 'infinity', dimensions: 1024 },
     'jinaai/jina-embeddings-v2-base-code': { provider: 'infinity', dimensions: 768 },
 };
 exports.DEFAULT_EMBED_MODEL = 'jinaai/jina-embeddings-v2-base-code';
-/**
- * Former Ollama registry model names, kept only so config validation can
- * recognise an implicit (provider-less) config that still targets Ollama —
- * see `detectFormerOllamaConfig` in `config-store.ts`.
- */
 exports.FORMER_OLLAMA_MODELS = ['bge-m3', 'nomic-embed-text', 'mxbai-embed-large'];
-/** Advisory dimension for a model, or `undefined` when the model is unknown. */
 function registryDimension(model) {
     return exports.MODEL_REGISTRY[model]?.dimensions;
 }
-/**
- * Resolve the effective vector dimension: explicit override → registry → probe.
- * Validates the result is ≤ MAX_EMBED_DIM, throwing an error that names
- * `embedding.dimensions` as the fix. `probeFn` embeds a short string once and
- * returns the observed length; only called when neither override nor registry
- * yields a value. Pure aside from the injected probe.
- */
 async function resolveDimension(override, model, probeFn, registry = exports.MODEL_REGISTRY) {
     let dim;
     if (override != null) {

package/dist/src/container.d.ts

@@ -1,6 +1,7 @@
 import { Config } from './config';
 import { IndexerService } from './services/IndexerService';
 import { McpServer } from './services/McpServer';
+import { LoggerService } from './services/LoggerService';
 import type { IDatabase } from './interfaces';
 import type { IEmbedder } from './interfaces';
 import type { ISearcher } from './interfaces';
@@ -16,4 +17,9 @@ export interface Container {
     logger: ILogger;
     discovery: IProjectDiscovery;
 }
+export declare function loggerBindingsFor(loggerName?: string): Record<string, unknown> | undefined;
+export declare function createLogger(cfg: {
+    level: string;
+    dir?: string;
+}, loggerName?: string): LoggerService;
 export declare function createContainer(loggerName?: string): Container;

package/dist/src/container.js

@@ -1,24 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerBindingsFor = loggerBindingsFor;
+exports.createLogger = createLogger;
 exports.createContainer = createContainer;
+const crypto_1 = require("crypto");
 const config_1 = require("./config");
 const DatabaseService_1 = require("./services/DatabaseService");
 const EmbedderFactory_1 = require("./services/EmbedderFactory");
 const AstParserService_1 = require("./services/AstParserService");
-const AstChunker_1 = require("./services/AstChunker");
+const create_chunker_1 = require("./chunking/create-chunker");
 const IndexerService_1 = require("./services/IndexerService");
 const SearcherService_1 = require("./services/SearcherService");
 const McpServer_1 = require("./services/McpServer");
 const LoggerService_1 = require("./services/LoggerService");
 const MonorepoAwareDiscoveryService_1 = require("./services/MonorepoAwareDiscoveryService");
 const NxMonorepoResolver_1 = require("./services/NxMonorepoResolver");
+function loggerBindingsFor(loggerName) {
+    return loggerName === 'mcp' ? { connectionId: (0, crypto_1.randomUUID)() } : undefined;
+}
+function createLogger(cfg, loggerName) {
+    return LoggerService_1.LoggerService.fromConfig(cfg, loggerName, loggerBindingsFor(loggerName));
+}
 function createContainer(loggerName) {
     const config = new config_1.Config();
-    const logger = LoggerService_1.LoggerService.fromConfig(config.logging, loggerName);
+    const logger = createLogger(config.logging, loggerName);
     const db = new DatabaseService_1.DatabaseService(config);
     const embedder = (0, EmbedderFactory_1.createEmbedder)(config, logger);
     const ast = new AstParserService_1.AstParserService(logger);
-    const chunker = new AstChunker_1.AstChunker(config);
+    const chunker = (0, create_chunker_1.createChunker)(config);
     const discovery = new MonorepoAwareDiscoveryService_1.MonorepoAwareDiscoveryService([new NxMonorepoResolver_1.NxMonorepoResolver(logger)], logger);
     const indexer = new IndexerService_1.IndexerService(db, embedder, ast, chunker, config, logger);
     const searcher = new SearcherService_1.SearcherService(db, embedder, discovery, config, logger);

package/dist/src/db/schema.d.ts

@@ -161,6 +161,23 @@ export declare const codeChunk: import("drizzle-orm/pg-core").PgTableWithColumns
         }, {}, {
             length: number | undefined;
         }>;
+        endLine: import("drizzle-orm/pg-core").PgColumn<{
+            name: "endLine";
+            tableName: "code_chunk";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: "pg";
 }>;

package/dist/src/db/schema.js

@@ -2,10 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexMeta = exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
 const pg_core_1 = require("drizzle-orm/pg-core");
-// NOTE: the `dimensions` literal below is nominal only. `dataType()` is invoked
-// solely by drizzle-kit DDL generation, which this project does not use — the
-// `code_chunk` table is created by raw SQL in DatabaseService at the dimension
-// resolved from the active model, and the real width is recorded in index_meta.
 const vector = (0, pg_core_1.customType)({
     dataType(config) { return `vector(${config?.dimensions ?? 1024})`; },
 });
@@ -19,6 +15,7 @@ exports.codeChunk = (0, pg_core_1.pgTable)('code_chunk', {
     lastModified: (0, pg_core_1.doublePrecision)('lastModified'),
     contentHash: (0, pg_core_1.varchar)('contentHash', { length: 64 }),
     ownerPath: (0, pg_core_1.varchar)('ownerPath'),
+    endLine: (0, pg_core_1.integer)('endLine'),
 });
 exports.codeDependency = (0, pg_core_1.pgTable)('code_dependency', {
     id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
@@ -53,8 +50,6 @@ exports.codeCall = (0, pg_core_1.pgTable)('code_call', {
     line: (0, pg_core_1.integer)('line'),
     col: (0, pg_core_1.integer)('col'),
 });
-// Single-row source of truth for which model built the current index. The
-// `id` column is a boolean pinned to `true` so at most one row can exist.
 exports.indexMeta = (0, pg_core_1.pgTable)('index_meta', {
     id: (0, pg_core_1.boolean)('id').primaryKey().default(true),
     provider: (0, pg_core_1.text)('provider').notNull(),

package/dist/src/declarations/DeclarationTree.d.ts

@@ -0,0 +1,19 @@
+import type { SymbolKind } from '../interfaces/IAstParser';
+import type { LineRange } from './SourceLines';
+export interface DeclarationNode {
+    start: number;
+    end: number;
+    nameLine: number;
+    qualifiedName: string;
+    kind: SymbolKind;
+    children: DeclarationNode[];
+}
+export declare class DeclarationTree {
+    static readonly EMPTY: DeclarationTree;
+    readonly roots: DeclarationNode[];
+    constructor(roots: DeclarationNode[]);
+    contains(line: number): boolean;
+    smallestContaining(lines: number[]): DeclarationNode | null;
+    within(range: LineRange): DeclarationNode[];
+    private static sorted;
+}

package/dist/src/declarations/DeclarationTree.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeclarationTree = void 0;
+class DeclarationTree {
+    static EMPTY = new DeclarationTree([]);
+    roots;
+    constructor(roots) {
+        this.roots = DeclarationTree.sorted(roots);
+    }
+    contains(line) {
+        return this.roots.some(r => r.start <= line && line <= r.end);
+    }
+    smallestContaining(lines) {
+        if (lines.length === 0)
+            return null;
+        const lo = Math.min(...lines);
+        const hi = Math.max(...lines);
+        const covers = (n) => n.start <= lo && n.end >= hi;
+        const span = (n) => n.end - n.start;
+        let fewest = Infinity;
+        const measure = (nodes) => {
+            for (const node of nodes) {
+                if (!covers(node))
+                    continue;
+                fewest = Math.min(fewest, span(node));
+                measure(node.children);
+            }
+        };
+        measure(this.roots);
+        let best = null;
+        const pick = (nodes) => {
+            let anyTied = false;
+            for (const node of nodes) {
+                if (!covers(node))
+                    continue;
+                const nestedTied = pick(node.children);
+                const tied = span(node) === fewest;
+                if (tied && !nestedTied && (best === null || node.nameLine < best.nameLine))
+                    best = node;
+                anyTied ||= tied || nestedTied;
+            }
+            return anyTied;
+        };
+        pick(this.roots);
+        return best;
+    }
+    within(range) {
+        const out = [];
+        const visit = (nodes) => {
+            for (const node of nodes) {
+                if (node.end < range.start || node.start > range.end)
+                    continue;
+                out.push(node);
+                visit(node.children);
+            }
+        };
+        visit(this.roots);
+        return out;
+    }
+    static sorted(nodes) {
+        return [...nodes]
+            .sort((a, b) => a.start - b.start || b.end - a.end)
+            .map(n => ({ ...n, children: DeclarationTree.sorted(n.children) }));
+    }
+}
+exports.DeclarationTree = DeclarationTree;

package/dist/src/declarations/DeclarationTreeBuilder.d.ts

@@ -0,0 +1,22 @@
+import { Node, type SourceFile } from 'ts-morph';
+import type { SymbolEntry } from '../interfaces/IAstParser';
+import { DeclarationTree } from './DeclarationTree';
+export interface DeclarationCandidate {
+    entry: SymbolEntry;
+    declNode: Node;
+}
+export declare class DeclarationTreeBuilder {
+    build(sourceFile: SourceFile, candidates: DeclarationCandidate[]): DeclarationTree;
+    flat(candidates: DeclarationCandidate[]): DeclarationTree;
+    leadingStart(sourceFile: SourceFile, declNode: Node, lines?: LineIndex): number;
+    private safeLeadingStart;
+    private triviaNode;
+    private overloadSets;
+    private nearestCandidateAncestor;
+}
+declare class LineIndex {
+    private readonly starts;
+    constructor(text: string);
+    lineAt(pos: number): number;
+}
+export {};

package/dist/src/declarations/DeclarationTreeBuilder.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeclarationTreeBuilder = void 0;
+const ts_morph_1 = require("ts-morph");
+const DeclarationTree_1 = require("./DeclarationTree");
+class DeclarationTreeBuilder {
+    build(sourceFile, candidates) {
+        const lines = new LineIndex(sourceFile.getFullText());
+        const siblings = new SiblingIndex();
+        const groups = this.overloadSets(candidates.filter(c => c.entry.kind !== 'method_signature'), siblings);
+        const nodeOf = new Map();
+        const entries = [];
+        for (const group of groups) {
+            const first = group[0];
+            const last = group[group.length - 1];
+            const named = group.find(c => c.entry.hasBody) ?? first;
+            const node = {
+                start: this.safeLeadingStart(sourceFile, siblings.firstSignature(first.declNode), lines),
+                end: lines.lineAt(last.declNode.getEnd()),
+                nameLine: named.entry.line ?? first.declNode.getStartLineNumber(),
+                qualifiedName: named.entry.container ? `${named.entry.container}.${named.entry.name}` : named.entry.name,
+                kind: named.entry.kind,
+                children: [],
+            };
+            for (const c of group)
+                nodeOf.set(c.declNode, node);
+            entries.push({ first: first.declNode, node });
+        }
+        const roots = [];
+        for (const { first, node } of entries) {
+            const parent = this.nearestCandidateAncestor(first, nodeOf);
+            if (parent && parent !== node) {
+                node.start = Math.max(node.start, parent.start);
+                parent.children.push(node);
+            }
+            else {
+                roots.push(node);
+            }
+        }
+        return new DeclarationTree_1.DeclarationTree(roots);
+    }
+    flat(candidates) {
+        const siblings = new SiblingIndex();
+        return new DeclarationTree_1.DeclarationTree(this.overloadSets(candidates, siblings).map(group => {
+            const first = group[0];
+            const named = group.find(c => c.entry.hasBody) ?? first;
+            return {
+                start: siblings.firstSignature(first.declNode).getStartLineNumber(),
+                end: group[group.length - 1].declNode.getEndLineNumber(),
+                nameLine: named.entry.line ?? first.declNode.getStartLineNumber(),
+                qualifiedName: named.entry.container ? `${named.entry.container}.${named.entry.name}` : named.entry.name,
+                kind: named.entry.kind,
+                children: [],
+            };
+        }));
+    }
+    leadingStart(sourceFile, declNode, lines = new LineIndex(sourceFile.getFullText())) {
+        const triviaNode = this.triviaNode(declNode);
+        let boundary = Math.min(lines.lineAt(declNode.getStart()), lines.lineAt(triviaNode.getStart()));
+        const ranges = ts_morph_1.ts.getLeadingCommentRanges(sourceFile.getFullText(), triviaNode.getPos()) ?? [];
+        for (let i = ranges.length - 1; i >= 0; i--) {
+            const endLine = lines.lineAt(Math.max(ranges[i].pos, ranges[i].end - 1));
+            if (endLine < boundary - 1)
+                break;
+            boundary = Math.min(boundary, lines.lineAt(ranges[i].pos));
+        }
+        return boundary;
+    }
+    safeLeadingStart(sourceFile, declNode, lines) {
+        try {
+            return this.leadingStart(sourceFile, declNode, lines);
+        }
+        catch {
+            return declNode.getStartLineNumber();
+        }
+    }
+    triviaNode(declNode) {
+        if (!ts_morph_1.Node.isVariableDeclaration(declNode))
+            return declNode;
+        const list = declNode.getParent();
+        const statement = list?.getParent();
+        if (!ts_morph_1.Node.isVariableDeclarationList(list) || !ts_morph_1.Node.isVariableStatement(statement))
+            return declNode;
+        return list.getDeclarations()[0] === declNode ? statement : declNode;
+    }
+    overloadSets(candidates, siblings) {
+        const key = (c) => JSON.stringify([c.entry.container, c.entry.name, c.entry.kind, c.entry.isStatic]);
+        const sorted = [...candidates].sort((a, b) => a.declNode.getStart() - b.declNode.getStart());
+        const sets = [];
+        const openSet = new Map();
+        for (const c of sorted) {
+            const k = key(c);
+            const open = openSet.get(k);
+            const prev = open?.[open.length - 1];
+            if (open && prev && siblings.adjacent(prev.declNode, c.declNode)) {
+                open.push(c);
+                continue;
+            }
+            const set = [c];
+            sets.push(set);
+            openSet.set(k, set);
+        }
+        return sets;
+    }
+    nearestCandidateAncestor(declNode, nodeOf) {
+        for (let current = declNode.getParent(); current; current = current.getParent()) {
+            const found = nodeOf.get(current);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+}
+exports.DeclarationTreeBuilder = DeclarationTreeBuilder;
+class SiblingIndex {
+    positions = new Map();
+    read = new Set();
+    statements = new Map();
+    adjacent(a, b) {
+        const pa = this.position(a.compilerNode);
+        const pb = this.position(b.compilerNode);
+        return !!pa && !!pb && pa.list === pb.list && pb.index === pa.index + 1;
+    }
+    firstSignature(declNode) {
+        if (!ts_morph_1.Node.isFunctionDeclaration(declNode) || !declNode.compilerNode.body)
+            return declNode;
+        const name = declNode.getName();
+        const position = this.position(declNode.compilerNode);
+        if (!name || !position)
+            return declNode;
+        const isSignature = (n) => ts_morph_1.ts.isFunctionDeclaration(n) && !n.body && n.name?.text === name;
+        let i = position.index;
+        while (i > 0 && isSignature(position.list[i - 1]))
+            i--;
+        if (i === position.index)
+            return declNode;
+        return this.statement(declNode.getParentOrThrow(), position.list[i]) ?? declNode;
+    }
+    position(node) {
+        const parent = node.parent;
+        if (parent && !this.read.has(parent)) {
+            this.read.add(parent);
+            ts_morph_1.ts.forEachChild(parent, () => undefined, list => {
+                list.forEach((child, index) => this.positions.set(child, { list, index }));
+                return undefined;
+            });
+        }
+        return this.positions.get(node);
+    }
+    statement(parent, compilerNode) {
+        if (!ts_morph_1.Node.isStatemented(parent))
+            return undefined;
+        let byCompilerNode = this.statements.get(parent);
+        if (!byCompilerNode) {
+            byCompilerNode = new Map(parent.getStatements().map(s => [s.compilerNode, s]));
+            this.statements.set(parent, byCompilerNode);
+        }
+        return byCompilerNode.get(compilerNode);
+    }
+}
+class LineIndex {
+    starts = [0];
+    constructor(text) {
+        for (let i = text.indexOf('\n'); i !== -1; i = text.indexOf('\n', i + 1))
+            this.starts.push(i + 1);
+    }
+    lineAt(pos) {
+        let lo = 0;
+        let hi = this.starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (this.starts[mid] <= pos)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo + 1;
+    }
+}

package/dist/src/declarations/SourceLines.d.ts

@@ -0,0 +1,37 @@
+export interface LineRange {
+    start: number;
+    end: number;
+}
+export declare class SourceLines {
+    readonly text: string;
+    private readonly lines;
+    private readonly stripped;
+    private readonly code;
+    private readonly startsInCode;
+    private importLines?;
+    constructor(text: string, { jsx }?: {
+        jsx?: boolean;
+    });
+    get count(): number;
+    line(n: number): string;
+    slice(start: number, end: number): string;
+    length(start: number, end: number): number;
+    isBlank(n: number): boolean;
+    isCommentOnly(n: number): boolean;
+    isDirective(n: number): boolean;
+    isPunctuationOnly(n: number): boolean;
+    isSignificant(n: number): boolean;
+    significantLength(start: number, end: number): number;
+    importRegions(start: number, end: number): LineRange[];
+    private importStatementEnd;
+    private startsImport;
+    private nextCode;
+    private static bracketDepth;
+    static isImportOrReexportOnly(content: string): boolean;
+    isImportOnly(start: number, end: number): boolean;
+    private importStatementLines;
+    private static isImportLine;
+    private static statements;
+    private static opensElement;
+    private static scanCode;
+}