codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/workspace/fs-access.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_FS = void 0;
+exports.errorCode = errorCode;
+const fs = __importStar(require("fs"));
+exports.NODE_FS = {
+    realpath: p => fs.promises.realpath(p),
+    stat: p => fs.promises.stat(p),
+    readdir: p => fs.promises.readdir(p, { withFileTypes: true }),
+    createReadStream: p => fs.createReadStream(p),
+};
+function errorCode(err) {
+    return err?.code ?? 'EIO';
+}

package/dist/src/workspace/path-helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function stripTrailingSlash(p: string): string;
+export declare function isWithin(p: string, root: string): boolean;
+export declare function editDistance(a: string, b: string, max: number): number;

package/dist/src/workspace/path-helpers.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripTrailingSlash = stripTrailingSlash;
+exports.isWithin = isWithin;
+exports.editDistance = editDistance;
+function stripTrailingSlash(p) {
+    return p.length > 1 && p.endsWith('/') ? p.slice(0, -1) : p;
+}
+function isWithin(p, root) {
+    if (root === '.')
+        return true;
+    if (root === '/')
+        return p.startsWith('/');
+    return p === root || p.startsWith(root + '/');
+}
+function editDistance(a, b, max) {
+    const x = [...a];
+    const y = [...b];
+    const over = max + 1;
+    if (Math.abs(x.length - y.length) > max)
+        return over;
+    let prev = Array.from({ length: y.length + 1 }, (_, j) => (j <= max ? j : over));
+    let row = new Array(y.length + 1).fill(over);
+    for (let i = 1; i <= x.length; i++) {
+        const from = Math.max(1, i - max);
+        const to = Math.min(y.length, i + max);
+        row[0] = i <= max ? i : over;
+        row[from - 1] = from === 1 ? row[0] : over;
+        let best = row[0];
+        for (let j = from; j <= to; j++) {
+            const cell = Math.min(prev[j] + 1, row[j - 1] + 1, prev[j - 1] + (x[i - 1] === y[j - 1] ? 0 : 1), over);
+            row[j] = cell;
+            if (cell < best)
+                best = cell;
+        }
+        if (to < y.length)
+            row[to + 1] = over;
+        if (best > max)
+            return over;
+        [prev, row] = [row, prev];
+    }
+    return prev[y.length];
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "codesearch-mcp",
-  "version": "0.2.3-alpha",
+  "version": "0.4.0-alpha",
   "description": "Local semantic codebase search via MCP — indexes projects into pgvector, exposes search to Claude",
-  "license": "MIT",
+  "license": "AGPL-3.0-only",
   "keywords": [
     "mcp",
     "model-context-protocol",
@@ -16,7 +16,7 @@
     "infinity"
   ],
   "engines": {
-    "node": ">=18"
+    "node": "^22.13.0 || >=23.5.0"
   },
   "main": "dist/app.js",
   "bin": {
@@ -29,7 +29,7 @@
   "files": [
     "dist/",
     "docker/",
-    "docs/",
+    "docs/architecture.svg",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -65,6 +65,7 @@
     "@types/cli-progress": "^3.11.6",
     "@types/node": "^22.0.0",
     "@types/pg": "^8.20.0",
+    "ai-aleks-tool": "^2.5.4",
     "ts-node": "^10.9.2",
     "typescript": "^5.6.0",
     "vitest": "^5.0.5"

package/dist/src/interfaces/ISearcher.d.ts

@@ -1,35 +0,0 @@
-import type { SearchResult, NeighborResult, GraphContext, DependencyRow, ProjectRow, SymbolKind, SymbolHit, CallerRow, FileRangeResult, ListFilesResult, GrepSymbolResult, ResolvedToolPath, PathFailure } from '../services/SearcherService';
-/**
- * Searcher abstraction — McpServer depends on this interface
- * rather than the concrete SearcherService.
- */
-export interface ISearcher {
-    prepareQuery(raw: string): Promise<{
-        query: string;
-        translated: boolean;
-    }>;
-    assertIndexMatches(): Promise<void>;
-    listProjects(): Promise<ProjectRow[]>;
-    getProjectEdges(): Promise<{
-        from: string;
-        to: string;
-    }[]>;
-    searchChunks(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean): Promise<SearchResult[]>;
-    fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
-    fetchGraphContext(results: SearchResult[]): Promise<Map<string, GraphContext>>;
-    getDependencies(filePath: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
-    getDependents(filePath: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
-    getCallers(symbol: string, project: string, calleeFile?: string | null): Promise<CallerRow[]>;
-    grepSymbol(symbol: string, rootDir: string, excludeFile: string): Promise<GrepSymbolResult>;
-    findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<{
-        hits: SymbolHit[];
-        truncated: boolean;
-        grepFailed: boolean;
-    }>;
-    listFiles(relPath: string, depth: number, pattern: string | null): Promise<ListFilesResult>;
-    readFile(relPath: string, maxLines: number): Promise<FileRangeResult>;
-    readFileRange(relPath: string, startLine: number, endLine: number): Promise<FileRangeResult>;
-    resolveToolPath(input: string | null | undefined): Promise<ResolvedToolPath>;
-    checkGraphPath(relPath: string): Promise<PathFailure | null>;
-    fallbackRoot(relPath: string): string | null;
-}

package/dist/src/services/AstChunker.d.ts

@@ -1,42 +0,0 @@
-import type { Config } from '../config';
-import type { IChunker, ChunkPiece, ChunkOpts } from '../interfaces/IChunker';
-/**
- * Splits TS/JS source into embeddable pieces aligned to top-level declaration
- * ranges (AST strategy). Falls back to the character-based recursive splitter
- * for schema files, files without symbol analysis, or when strategy is
- * 'character' — that path is byte-for-byte the previous behavior.
- */
-export declare class AstChunker implements IChunker {
-    private config;
-    private readonly jsSplitter;
-    private readonly schemaSplitter;
-    private readonly chunkSize;
-    constructor(config: Config);
-    chunk(code: string, opts: ChunkOpts): Promise<ChunkPiece[]>;
-    private produce;
-    /**
-     * True iff every significant line (blank and comment lines stripped) belongs
-     * to an `import` / re-export statement and at least one is an import or
-     * re-export keyword — so the chunk carries no value/type declaration and is
-     * never a search answer. Any `export const|let|var|function|class|interface|
-     * enum|namespace|default|declare|async function|type X = …` disqualifies
-     * exclusion. Pure. Distinguishes `export { … } from` / `export type { … }`
-     * (re-export → drop) from `export type X = …` (declaration → keep).
-     */
-    static isImportOrReexportOnly(content: string): boolean;
-    /** Character-splitter path for a whole file; line numbers from splitter metadata. */
-    private splitWholeFile;
-    private chunkByAst;
-    /**
-     * Build disjoint, sorted line intervals from symbol ranges. Overlapping /
-     * nested ranges merge into the outermost (a merged region covers any symbol
-     * inside it). Ranges are clamped to the file's line count.
-     */
-    private static buildIntervals;
-    /**
-     * Emit pieces for a 1-based inclusive line region. Whitespace-only gaps are
-     * dropped; regions longer than chunkSize are sub-split with the char splitter,
-     * with sub-piece line numbers offset back to absolute file lines.
-     */
-    private regionPieces;
-}

package/dist/src/services/AstChunker.js

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AstChunker = void 0;
-const textsplitters_1 = require("@langchain/textsplitters");
-/**
- * Splits TS/JS source into embeddable pieces aligned to top-level declaration
- * ranges (AST strategy). Falls back to the character-based recursive splitter
- * for schema files, files without symbol analysis, or when strategy is
- * 'character' — that path is byte-for-byte the previous behavior.
- */
-class AstChunker {
-    config;
-    jsSplitter;
-    schemaSplitter;
-    chunkSize;
-    constructor(config) {
-        this.config = config;
-        this.chunkSize = config.indexer.chunkSize;
-        this.jsSplitter = textsplitters_1.RecursiveCharacterTextSplitter.fromLanguage('js', {
-            chunkSize: config.indexer.chunkSize,
-            chunkOverlap: config.indexer.chunkOverlap,
-        });
-        this.schemaSplitter = new textsplitters_1.RecursiveCharacterTextSplitter({
-            chunkSize: config.indexer.chunkSize,
-            chunkOverlap: config.indexer.chunkOverlap,
-            separators: ['\n\n', '\n', ' '],
-        });
-    }
-    async chunk(code, opts) {
-        const pieces = await this.produce(code, opts);
-        // Single post-chunk pass: drop pieces whose only significant content is
-        // import / re-export statements. Both chunk sources — AST "gap" regions and
-        // the whole-file character path for barrel files — can emit these, so we
-        // filter once over the final pieces. Dependency edges are untouched (they
-        // come from analyzeProject → code_dependency, not from chunk text).
-        return pieces.filter(p => !AstChunker.isImportOrReexportOnly(p.content));
-    }
-    async produce(code, opts) {
-        if (opts.isSchemaFile) {
-            return this.splitWholeFile(code, this.schemaSplitter);
-        }
-        if (opts.strategy === 'character' || opts.symbols.length === 0) {
-            return this.splitWholeFile(code, this.jsSplitter);
-        }
-        return this.chunkByAst(code, opts.symbols);
-    }
-    /**
-     * True iff every significant line (blank and comment lines stripped) belongs
-     * to an `import` / re-export statement and at least one is an import or
-     * re-export keyword — so the chunk carries no value/type declaration and is
-     * never a search answer. Any `export const|let|var|function|class|interface|
-     * enum|namespace|default|declare|async function|type X = …` disqualifies
-     * exclusion. Pure. Distinguishes `export { … } from` / `export type { … }`
-     * (re-export → drop) from `export type X = …` (declaration → keep).
-     */
-    static isImportOrReexportOnly(content) {
-        const lines = content
-            .replace(/\/\*[\s\S]*?\*\//g, '') // strip block comments
-            .split('\n')
-            .map(l => l.trim())
-            .filter(l => l !== '' && !l.startsWith('//') && !l.startsWith('*'));
-        if (lines.length === 0)
-            return false;
-        const IMPORT = /^import\b/;
-        const REEXPORT = /^export\s+(\*|type\s+\{|\{)/; // export * | export type { | export {
-        const DISQUALIFY = /^export\s+(default|async\b|function\b|const\b|let\b|var\b|class\b|abstract\b|interface\b|enum\b|namespace\b|declare\b|type\s+[A-Za-z_$])/;
-        const CONTINUATION = /^(\}?\s*from\s+['"][^'"]+['"];?|[{}]|(type\s+)?[A-Za-z_$][\w$]*(\s+as\s+[A-Za-z_$][\w$]*)?,?|['"][^'"]*['"];?)$/;
-        let keywords = 0;
-        for (const line of lines) {
-            if (DISQUALIFY.test(line))
-                return false;
-            if (IMPORT.test(line) || REEXPORT.test(line)) {
-                keywords++;
-                continue;
-            }
-            if (CONTINUATION.test(line))
-                continue;
-            return false; // unrecognized line → real code, keep the chunk
-        }
-        return keywords >= 1;
-    }
-    /** Character-splitter path for a whole file; line numbers from splitter metadata. */
-    async splitWholeFile(code, splitter) {
-        const docs = await splitter.createDocuments([code]);
-        return docs.map((d) => {
-            const from = (d.metadata?.loc?.lines?.from ?? 1);
-            const to = (d.metadata?.loc?.lines?.to ?? from);
-            return { content: d.pageContent, startLine: from, endLine: to };
-        });
-    }
-    async chunkByAst(code, symbols) {
-        const lines = code.split('\n');
-        const total = lines.length;
-        const intervals = AstChunker.buildIntervals(symbols, total);
-        const pieces = [];
-        let cursor = 1;
-        for (const iv of intervals) {
-            if (cursor < iv.start) {
-                pieces.push(...await this.regionPieces(lines, cursor, iv.start - 1, true));
-            }
-            pieces.push(...await this.regionPieces(lines, iv.start, iv.end, false));
-            cursor = iv.end + 1;
-        }
-        if (cursor <= total) {
-            pieces.push(...await this.regionPieces(lines, cursor, total, true));
-        }
-        return pieces;
-    }
-    /**
-     * Build disjoint, sorted line intervals from symbol ranges. Overlapping /
-     * nested ranges merge into the outermost (a merged region covers any symbol
-     * inside it). Ranges are clamped to the file's line count.
-     */
-    static buildIntervals(symbols, total) {
-        const raw = symbols
-            .filter(s => s.line != null && s.line >= 1 && s.line <= total)
-            .map(s => ({
-            start: s.line,
-            end: Math.min(Math.max(s.endLine ?? s.line, s.line), total),
-        }))
-            .sort((a, b) => a.start - b.start || b.end - a.end);
-        const merged = [];
-        for (const iv of raw) {
-            const last = merged[merged.length - 1];
-            if (last && iv.start <= last.end) {
-                last.end = Math.max(last.end, iv.end);
-            }
-            else {
-                merged.push({ ...iv });
-            }
-        }
-        return merged;
-    }
-    /**
-     * Emit pieces for a 1-based inclusive line region. Whitespace-only gaps are
-     * dropped; regions longer than chunkSize are sub-split with the char splitter,
-     * with sub-piece line numbers offset back to absolute file lines.
-     */
-    async regionPieces(lines, start, end, isGap) {
-        const text = lines.slice(start - 1, end).join('\n');
-        if (isGap && text.trim() === '')
-            return [];
-        if (text.length <= this.chunkSize) {
-            return [{ content: text, startLine: start, endLine: end }];
-        }
-        const docs = await this.jsSplitter.createDocuments([text]);
-        return docs.map((d) => {
-            const from = (d.metadata?.loc?.lines?.from ?? 1);
-            const to = (d.metadata?.loc?.lines?.to ?? from);
-            return {
-                content: d.pageContent,
-                startLine: start + from - 1,
-                endLine: start + to - 1,
-            };
-        });
-    }
-}
-exports.AstChunker = AstChunker;