codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/dist/src/workspace/WorkspaceFiles.js

@@ -0,0 +1,285 @@
+"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.WorkspaceFiles = void 0;
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const stream_1 = require("stream");
+const file_utils_1 = require("../file-utils");
+const fs_access_1 = require("./fs-access");
+const MAX_LINE_BYTES = 64 * 1024 * 1024;
+const LINE_TOO_LONG = 'ELINETOOLONG';
+const BINARY_FILE = 'EBINARY';
+const BINARY_SNIFF_BYTES = 8 * 1024;
+const LF = 0x0a;
+const CR = 0x0d;
+function openLineBytes(open, chunk) {
+    const breaks = [chunk.indexOf(LF), chunk.indexOf(CR)].filter(i => i >= 0);
+    const head = breaks.length === 0 ? chunk.length : Math.min(...breaks);
+    const total = open + head;
+    if (total > MAX_LINE_BYTES)
+        return null;
+    if (breaks.length === 0)
+        return total;
+    return chunk.length - 1 - Math.max(chunk.lastIndexOf(LF), chunk.lastIndexOf(CR));
+}
+function lineLimitGuard() {
+    let open = 0;
+    let sniffed = 0;
+    let held = [];
+    const lineLimit = (chunk) => {
+        const next = openLineBytes(open, chunk);
+        if (next === null)
+            return Object.assign(new Error('line too long'), { code: LINE_TOO_LONG });
+        open = next;
+        return null;
+    };
+    return new stream_1.Transform({
+        encoding: 'utf-8',
+        transform(chunk, _encoding, done) {
+            if (sniffed < BINARY_SNIFF_BYTES) {
+                const head = chunk.subarray(0, BINARY_SNIFF_BYTES - sniffed);
+                if (head.includes(0)) {
+                    done(Object.assign(new Error('binary file'), { code: BINARY_FILE }));
+                    return;
+                }
+                sniffed += head.length;
+                held.push(chunk);
+                if (sniffed < BINARY_SNIFF_BYTES) {
+                    done();
+                    return;
+                }
+                chunk = Buffer.concat(held);
+                held = [];
+            }
+            const err = lineLimit(chunk);
+            if (err)
+                done(err);
+            else
+                done(null, chunk);
+        },
+        flush(done) {
+            if (held.length === 0) {
+                done();
+                return;
+            }
+            const chunk = Buffer.concat(held);
+            held = [];
+            const err = lineLimit(chunk);
+            if (err)
+                done(err);
+            else
+                done(null, chunk);
+        },
+    });
+}
+class WorkspaceFiles {
+    paths;
+    roots;
+    logger;
+    fs;
+    constructor(paths, roots, logger, fs) {
+        this.paths = paths;
+        this.roots = roots;
+        this.logger = logger;
+        this.fs = fs;
+    }
+    async listFiles(relPath, depth, pattern) {
+        const t0 = Date.now();
+        this.logger.debug('WorkspaceFiles: listFiles', { relPath, depth, pattern });
+        const absPath = this.roots.toAbs(relPath);
+        const loc = await this.paths.checkRealLocation(relPath, absPath, 'dir');
+        if (!loc.ok)
+            return loc;
+        let stat;
+        try {
+            stat = await this.fs.stat(absPath);
+        }
+        catch (err) {
+            if ((0, fs_access_1.errorCode)(err) !== 'ENOENT')
+                return { ok: false, reason: 'unreadable', code: (0, fs_access_1.errorCode)(err) };
+            return { ok: false, reason: 'not_found', candidates: await this.paths.candidatesOrNone(relPath, 'dir') };
+        }
+        if (!stat.isDirectory())
+            return { ok: false, reason: 'not_a_directory' };
+        const clampedDepth = Math.min(5, Math.max(1, depth));
+        const lines = [];
+        try {
+            await this.walkDir(absPath, 0, clampedDepth - 1, pattern, lines);
+        }
+        catch (err) {
+            return { ok: false, reason: 'unreadable', code: (0, fs_access_1.errorCode)(err) };
+        }
+        this.logger.debug('WorkspaceFiles: listFiles result', { entries: lines.length, ms: Date.now() - t0 });
+        if (lines.length === 0) {
+            return { ok: true, tree: pattern ? `No files matching "${pattern}" found within depth ${clampedDepth}.` : '(empty directory)' };
+        }
+        return { ok: true, tree: lines.join('\n') };
+    }
+    async openableFile(relPath, absPath) {
+        const loc = await this.paths.checkRealLocation(relPath, absPath, 'file');
+        if (!loc.ok)
+            return loc;
+        let stat;
+        try {
+            stat = await this.fs.stat(absPath);
+        }
+        catch (err) {
+            if ((0, fs_access_1.errorCode)(err) !== 'ENOENT')
+                return { ok: false, reason: 'unreadable', code: (0, fs_access_1.errorCode)(err) };
+            if (await this.paths.isIndexedPath(relPath))
+                return { ok: false, reason: 'deleted' };
+            return { ok: false, reason: 'not_found', candidates: await this.paths.candidatesOrNone(relPath, 'file') };
+        }
+        return stat.isFile() ? null : { ok: false, reason: 'not_a_file' };
+    }
+    async readLines(absPath, onLine) {
+        const stream = this.fs.createReadStream(absPath);
+        const guard = lineLimitGuard();
+        guard.on('error', () => { });
+        stream.on('error', err => guard.destroy(err));
+        stream.pipe(guard);
+        const rl = readline.createInterface({ input: guard, crlfDelay: Infinity });
+        let lineNo = 0;
+        try {
+            for await (const line of rl) {
+                lineNo++;
+                if (!onLine(line, lineNo))
+                    break;
+            }
+            return { ok: true, lineCount: lineNo };
+        }
+        catch (err) {
+            if ((0, fs_access_1.errorCode)(err) === LINE_TOO_LONG && !onLine('', lineNo + 1))
+                return { ok: true, lineCount: lineNo };
+            return { ok: false, code: (0, fs_access_1.errorCode)(err) };
+        }
+        finally {
+            rl.close();
+            guard.destroy();
+            stream.destroy?.();
+        }
+    }
+    readFailure(code) {
+        return code === BINARY_FILE ? { ok: false, reason: 'binary' } : { ok: false, reason: 'unreadable', code };
+    }
+    async readFile(relPath, maxLines) {
+        const t0 = Date.now();
+        this.logger.debug('WorkspaceFiles: readFile', { relPath, maxLines });
+        const absPath = this.roots.toAbs(relPath);
+        const failure = await this.openableFile(relPath, absPath);
+        if (failure)
+            return failure;
+        const lines = [];
+        let hasMore = false;
+        const read = await this.readLines(absPath, line => {
+            if (lines.length < maxLines) {
+                lines.push(line);
+                return true;
+            }
+            hasMore = true;
+            return false;
+        });
+        if (!read.ok)
+            return this.readFailure(read.code);
+        this.logger.debug('WorkspaceFiles: readFile result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
+        return { ok: true, filePath: relPath, startLine: 1, endLine: lines.length, lines, hasMore };
+    }
+    async readFileRange(relPath, startLine, endLine) {
+        const t0 = Date.now();
+        this.logger.debug('WorkspaceFiles: readFileRange', { relPath, startLine, endLine });
+        if (endLine < startLine)
+            return { ok: false, reason: 'bad_range', startLine, endLine };
+        const absPath = this.roots.toAbs(relPath);
+        const failure = await this.openableFile(relPath, absPath);
+        if (failure)
+            return failure;
+        const lines = [];
+        let lastRead = 0;
+        let hasMore = false;
+        const read = await this.readLines(absPath, (line, lineNo) => {
+            if (lineNo > endLine) {
+                hasMore = true;
+                return false;
+            }
+            if (lineNo >= startLine)
+                lines.push(line);
+            lastRead = lineNo;
+            return true;
+        });
+        if (!read.ok)
+            return this.readFailure(read.code);
+        if (!hasMore && startLine > Math.max(read.lineCount, 1)) {
+            return { ok: false, reason: 'past_end', lineCount: read.lineCount, startLine };
+        }
+        this.logger.debug('WorkspaceFiles: readFileRange result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
+        return { ok: true, filePath: relPath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
+    }
+    async walkDir(absDir, currentDepth, maxDepth, pattern, lines) {
+        const entries = await this.fs.readdir(absDir);
+        entries.sort((a, b) => {
+            const ad = a.isDirectory() ? 0 : 1;
+            const bd = b.isDirectory() ? 0 : 1;
+            if (ad !== bd)
+                return ad - bd;
+            return a.name.localeCompare(b.name);
+        });
+        for (const entry of entries) {
+            if (file_utils_1.IGNORE_DIRS.has(entry.name))
+                continue;
+            const indent = '  '.repeat(currentDepth);
+            if (entry.isDirectory()) {
+                const at = lines.push(`${indent}${entry.name}/`) - 1;
+                if (currentDepth < maxDepth) {
+                    try {
+                        await this.walkDir(path.join(absDir, entry.name), currentDepth + 1, maxDepth, pattern, lines);
+                    }
+                    catch {
+                        lines[at] += ' (unreadable)';
+                        continue;
+                    }
+                }
+                if (pattern && lines.length === at + 1)
+                    lines.pop();
+            }
+            else {
+                if (pattern && !entry.name.includes(pattern))
+                    continue;
+                lines.push(`${indent}${entry.name}`);
+            }
+        }
+    }
+}
+exports.WorkspaceFiles = WorkspaceFiles;

package/dist/src/workspace/fs-access.d.ts

@@ -0,0 +1,9 @@
+import * as fs from 'fs';
+export interface WorkspaceFs {
+    realpath(p: string): Promise<string>;
+    stat(p: string): Promise<fs.Stats>;
+    readdir(p: string): Promise<fs.Dirent[]>;
+    createReadStream(p: string): NodeJS.ReadableStream;
+}
+export declare const NODE_FS: WorkspaceFs;
+export declare function errorCode(err: unknown): string;

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.3.0-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": {
@@ -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,46 +0,0 @@
-import type { SearchResult, NeighborResult, GraphContext, DependencyRow, ProjectRow, SymbolKind, SymbolHit, CallerRow, FileRangeResult, ListFilesResult, GrepSymbolResult, ResolvedToolPath, PathFailure } from '../services/SearcherService';
-export type StageName = 'vector' | 'reranked';
-export interface StagedSearchResult {
-    pool: SearchResult[];
-    stages: {
-        vector: SearchResult[];
-        reranked?: SearchResult[];
-    };
-    rerankFailed: boolean;
-    fetchLimit: number;
-    indexParams: {
-        efSearch: number | null;
-        iterativeScan: string;
-    };
-}
-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, perFile?: number): Promise<SearchResult[]>;
-    searchChunksWithStages(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean, perFile?: number): Promise<StagedSearchResult>;
-    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;
-}