codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

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

@@ -0,0 +1,8 @@
+import type { IDatabase } from '../interfaces/IDatabase';
+export type SchemaDb = Pick<IDatabase, 'query' | 'transaction' | 'ensureChunkTable'>;
+export interface SchemaStep {
+    readonly name: string;
+    run(db: SchemaDb): Promise<void>;
+}
+export declare const SCHEMA_STEPS: readonly SchemaStep[];
+export declare function runSchemaSteps(db: SchemaDb, steps?: readonly SchemaStep[]): Promise<void>;

package/dist/src/db/schema-steps.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_STEPS = void 0;
+exports.runSchemaSteps = runSchemaSteps;
+async function codeChunkTable(db) {
+    await db.ensureChunkTable(1024);
+}
+async function indexMetaTable(db) {
+    await db.query(`
+    CREATE TABLE IF NOT EXISTS index_meta (
+      id          BOOLEAN PRIMARY KEY DEFAULT true,
+      provider    TEXT NOT NULL,
+      model       TEXT NOT NULL,
+      dimensions  INT  NOT NULL,
+      "indexedAt" TIMESTAMPTZ NOT NULL DEFAULT now()
+    )
+  `);
+}
+async function codeDependencyTable(db) {
+    const [{ existsDep }] = await db.query(`
+    SELECT EXISTS (
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name = 'code_dependency'
+    ) AS "existsDep"
+  `);
+    if (!existsDep) {
+        await db.query(`
+      CREATE TABLE code_dependency (
+        id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        project      TEXT NOT NULL,
+        "fromFile"   TEXT NOT NULL,
+        "fromSymbol" TEXT,
+        "toFile"     TEXT NOT NULL,
+        "toSymbol"   TEXT,
+        "depType"    TEXT NOT NULL
+      )
+    `);
+    }
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_from ON code_dependency (project, "fromFile")`);
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_dep_project_to   ON code_dependency (project, "toFile")`);
+    await db.query(`DROP INDEX IF EXISTS idx_dep_from`);
+    await db.query(`DROP INDEX IF EXISTS idx_dep_to`);
+    await db.query(`DROP INDEX IF EXISTS idx_dep_project`);
+}
+async function codeSymbolTable(db) {
+    const [{ existsSym }] = await db.query(`
+    SELECT EXISTS (
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name = 'code_symbol'
+    ) AS "existsSym"
+  `);
+    if (!existsSym) {
+        await db.query(`
+      CREATE TABLE code_symbol (
+        id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        project    TEXT NOT NULL,
+        "filePath" TEXT NOT NULL,
+        name       TEXT NOT NULL,
+        kind       TEXT NOT NULL,
+        signature  TEXT,
+        line       INT,
+        col        INT
+      )
+    `);
+    }
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_symbol_name   ON code_symbol (name, project)`);
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_symbol_file   ON code_symbol (project, "filePath")`);
+    await db.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS container TEXT`);
+    await db.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "isStatic" BOOLEAN NOT NULL DEFAULT false`);
+    await db.query(`ALTER TABLE code_symbol ADD COLUMN IF NOT EXISTS "target" TEXT`);
+    await db.transaction(async (tx) => {
+        await tx.execute('DROP INDEX IF EXISTS idx_symbol_unique');
+        await tx.execute('CREATE UNIQUE INDEX IF NOT EXISTS idx_symbol_unique_v2 ' +
+            'ON code_symbol (project, "filePath", container, name, kind, line) NULLS NOT DISTINCT');
+    });
+}
+async function codeCallTable(db) {
+    await db.query(`
+    CREATE TABLE IF NOT EXISTS code_call (
+      id             UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+      project        TEXT NOT NULL,
+      "fromFile"     TEXT NOT NULL,
+      "fromSymbol"   TEXT,
+      "calleeName"   TEXT NOT NULL,
+      "calleeFile"   TEXT NOT NULL,
+      "calleeSymbol" TEXT,
+      line           INT,
+      col            INT
+    )
+  `);
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_call_callee      ON code_call (project, "calleeName")`);
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_call_callee_file ON code_call (project, "calleeFile")`);
+    await db.query(`CREATE INDEX IF NOT EXISTS idx_call_from        ON code_call (project, "fromFile")`);
+}
+exports.SCHEMA_STEPS = [
+    { name: 'codeChunkTable', run: codeChunkTable },
+    { name: 'indexMetaTable', run: indexMetaTable },
+    { name: 'codeDependencyTable', run: codeDependencyTable },
+    { name: 'codeSymbolTable', run: codeSymbolTable },
+    { name: 'codeCallTable', run: codeCallTable },
+];
+async function runSchemaSteps(db, steps = exports.SCHEMA_STEPS) {
+    for (const step of steps)
+        await step.run(db);
+}

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/SymbolKind';
+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;
+}