codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/error-record.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_SERIALIZERS = exports.MAX_AGGREGATED = exports.MAX_PARAM_CHARS = exports.MAX_PARAMS = exports.MAX_QUERY_CHARS = exports.MAX_FRAMES = exports.MAX_CAUSES = void 0;
+exports.serializeError = serializeError;
+exports.rootCauseMessage = rootCauseMessage;
+exports.errorMessage = errorMessage;
+const drizzle_orm_1 = require("drizzle-orm");
+exports.MAX_CAUSES = 5;
+exports.MAX_FRAMES = 30;
+exports.MAX_QUERY_CHARS = 500;
+exports.MAX_PARAMS = 30;
+exports.MAX_PARAM_CHARS = 120;
+exports.MAX_AGGREGATED = 10;
+const DRIVER_FIELDS = [
+    'code', 'errno', 'syscall', 'path', 'detail', 'hint', 'where', 'schema', 'table', 'column', 'constraint',
+];
+const FRAME_PREFIX = '    at ';
+function read(obj, key) {
+    try {
+        return obj[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+function isError(value) {
+    try {
+        return value instanceof Error;
+    }
+    catch {
+        return false;
+    }
+}
+function isAggregate(err) {
+    try {
+        return err instanceof AggregateError;
+    }
+    catch {
+        return false;
+    }
+}
+function headOf(value, max) {
+    try {
+        if (!Array.isArray(value))
+            return undefined;
+        const length = value.length;
+        const items = [];
+        const count = typeof length === 'number' ? Math.min(length, max) : 0;
+        for (let i = 0; i < count; i++)
+            items.push(value[i]);
+        return { items, total: typeof length === 'number' && length > items.length ? length : items.length };
+    }
+    catch {
+        return undefined;
+    }
+}
+function isDrizzle(err) {
+    try {
+        return err instanceof drizzle_orm_1.DrizzleQueryError;
+    }
+    catch {
+        return false;
+    }
+}
+function limit(text, max) {
+    return text.length > max ? `${text.slice(0, max)}…(+${text.length - max})` : text;
+}
+function typeOf(err) {
+    const ctor = read(err, 'constructor');
+    const ctorName = typeof ctor === 'function' ? read(ctor, 'name') : undefined;
+    if (typeof ctorName === 'string' && ctorName)
+        return ctorName;
+    const name = read(err, 'name');
+    return typeof name === 'string' ? name : 'Error';
+}
+function rawMessage(err) {
+    const message = read(err, 'message');
+    return typeof message === 'string' ? message : undefined;
+}
+function messageOf(err) {
+    const message = rawMessage(err);
+    if (message === undefined || !isDrizzle(err))
+        return message;
+    const tail = message.indexOf('\nparams: ');
+    return limit(tail === -1 ? message : message.slice(0, tail), exports.MAX_QUERY_CHARS);
+}
+function aggregatedOf(err) {
+    const head = isAggregate(err) ? headOf(read(err, 'errors'), exports.MAX_AGGREGATED) : undefined;
+    return head ?? { items: [], total: 0 };
+}
+function textOf(err) {
+    const message = messageOf(err);
+    if (message === undefined)
+        return typeOf(err);
+    if (message)
+        return message;
+    const nested = aggregatedOf(err).items.filter(isError).map(messageOf).filter((m) => !!m);
+    return nested.length ? [...new Set(nested)].join('; ') : typeOf(err);
+}
+function limitFrames(frames) {
+    if (frames.length <= exports.MAX_FRAMES)
+        return frames;
+    return [...frames.slice(0, exports.MAX_FRAMES), `    … +${frames.length - exports.MAX_FRAMES} frames`];
+}
+function stackOf(err, type, message) {
+    const stack = read(err, 'stack');
+    if (typeof stack !== 'string')
+        return undefined;
+    if (isDrizzle(err)) {
+        const name = read(err, 'name');
+        const raw = rawMessage(err) ?? '';
+        const native = `${typeof name === 'string' ? name : ''}${raw ? `: ${raw}` : ''}`;
+        const header = message !== undefined ? `${type}: ${message}` : type;
+        if (!stack.startsWith(`${native}\n`))
+            return header;
+        return [header, ...limitFrames(stack.slice(native.length + 1).split('\n'))].join('\n');
+    }
+    const lines = stack.split('\n');
+    const firstFrame = lines.findIndex(line => line.startsWith(FRAME_PREFIX));
+    if (firstFrame === -1)
+        return stack;
+    return [...lines.slice(0, firstFrame), ...limitFrames(lines.slice(firstFrame))].join('\n');
+}
+function renderParam(value) {
+    try {
+        if (value === null || typeof value === 'boolean' || typeof value === 'number')
+            return value;
+        if (typeof value === 'string')
+            return limit(value, exports.MAX_PARAM_CHARS);
+        if (value instanceof Date)
+            return value.toISOString();
+        if (Buffer.isBuffer(value))
+            return `[Buffer ${value.length} bytes]`;
+        const json = JSON.stringify(value);
+        if (typeof json === 'string')
+            return limit(json, exports.MAX_PARAM_CHARS);
+    }
+    catch {
+    }
+    try {
+        return limit(String(value), exports.MAX_PARAM_CHARS);
+    }
+    catch {
+        return '[unserializable]';
+    }
+}
+function compactParams({ items, total }) {
+    const values = items.map(renderParam);
+    if (total > exports.MAX_PARAMS)
+        values.push(`…(+${total - exports.MAX_PARAMS})`);
+    return { count: total, values };
+}
+function linkOf(err, expand = true) {
+    const type = typeOf(err);
+    const message = messageOf(err);
+    const link = { type };
+    if (message !== undefined)
+        link.message = message;
+    const stack = stackOf(err, type, message);
+    if (stack !== undefined)
+        link.stack = stack;
+    for (const field of DRIVER_FIELDS) {
+        const value = read(err, field);
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+            link[field] = value;
+    }
+    if (isDrizzle(err)) {
+        const query = read(err, 'query');
+        if (typeof query === 'string')
+            link.query = limit(query, exports.MAX_QUERY_CHARS);
+        const params = headOf(read(err, 'params'), exports.MAX_PARAMS);
+        if (params)
+            link.params = compactParams(params);
+    }
+    const nested = expand ? aggregatedOf(err) : { items: [], total: 0 };
+    if (nested.total) {
+        const errors = nested.items.map(e => (isError(e) ? linkOf(e, false) : { value: renderParam(e) }));
+        if (nested.total > exports.MAX_AGGREGATED)
+            errors.push(`…(+${nested.total - exports.MAX_AGGREGATED})`);
+        link.errors = errors;
+    }
+    return link;
+}
+function causeChain(err) {
+    const chain = { errors: [] };
+    const visited = new Set([err]);
+    let current = err;
+    for (;;) {
+        const cause = read(current, 'cause');
+        if (cause === undefined)
+            return chain;
+        if (chain.errors.length >= exports.MAX_CAUSES) {
+            chain.truncated = 'depth';
+            return chain;
+        }
+        if (!isError(cause)) {
+            chain.tail = { value: cause };
+            return chain;
+        }
+        if (visited.has(cause)) {
+            chain.truncated = 'cycle';
+            return chain;
+        }
+        visited.add(cause);
+        chain.errors.push(cause);
+        current = cause;
+    }
+}
+function serializeError(value) {
+    if (!isError(value))
+        return value;
+    const record = linkOf(value);
+    const chain = causeChain(value);
+    const causes = chain.errors.map(e => linkOf(e));
+    if (chain.tail)
+        causes.push(chain.tail);
+    if (causes.length)
+        record.causes = causes;
+    if (chain.truncated)
+        record.causesTruncated = chain.truncated;
+    return record;
+}
+function rootCauseMessage(value) {
+    if (!isError(value)) {
+        try {
+            return String(value);
+        }
+        catch {
+            return '[unserializable]';
+        }
+    }
+    const errors = causeChain(value).errors;
+    const root = errors.length ? errors[errors.length - 1] : value;
+    const code = read(root, 'code');
+    const text = textOf(root);
+    return typeof code === 'string' ? `${text} (${code})` : text;
+}
+function errorMessage(value) {
+    if (isError(value))
+        return textOf(value);
+    try {
+        return String(value);
+    }
+    catch {
+        return '[unserializable]';
+    }
+}
+exports.LOG_SERIALIZERS = { err: serializeError };

package/dist/src/eval-corpus.d.ts

@@ -0,0 +1,16 @@
+import type { ICorpusInspector } from './interfaces/ICorpusInspector';
+import type { IDatabase } from './interfaces/IDatabase';
+import type { CorpusRef } from './interfaces/IRetrievalEvaluator';
+export declare class GitCorpusInspector implements ICorpusInspector {
+    headCommit(root: string): Promise<string>;
+    trackedChanges(root: string): Promise<string[]>;
+    untrackedFiles(root: string, skipDirs: readonly string[]): Promise<string[]>;
+    listFiles(dir: string): Promise<string[]>;
+    readFile(absPath: string): Promise<Buffer | null>;
+}
+export declare function checkCorpus(corpus: CorpusRef, corpusDir: string, keptDir: string, inspector: ICorpusInspector): Promise<string[]>;
+export declare const FINGERPRINT_SQL = "SELECT COUNT(*)::int AS chunks,\n       md5(coalesce(string_agg(\n         \"serviceName\" || E'\\t' || \"filePath\" || E'\\t' || coalesce(\"startLine\"::text, '') || E'\\t'\n           || md5(content) || E'\\t' || coalesce(\"ownerPath\", '') || E'\\t' || md5(embedding::text),\n         E'\\n' ORDER BY \"serviceName\" COLLATE \"C\", \"filePath\" COLLATE \"C\", \"startLine\", md5(content)\n       ), '')) AS fingerprint\nFROM code_chunk\nWHERE \"serviceName\" = ANY($1::text[])";
+export declare function fingerprintCorpus(db: Pick<IDatabase, 'query'>, projects: string[]): Promise<{
+    chunks: number;
+    fingerprint: string;
+}>;

package/dist/src/eval-corpus.js

@@ -0,0 +1,169 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FINGERPRINT_SQL = exports.GitCorpusInspector = void 0;
+exports.checkCorpus = checkCorpus;
+exports.fingerprintCorpus = fingerprintCorpus;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const ignore_1 = __importDefault(require("ignore"));
+const file_utils_1 = require("./file-utils");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const RAGIGNORE = '.ragignore';
+async function git(root, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd: root, encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 });
+    return stdout;
+}
+function nulSeparated(out) {
+    return out.split('\0').filter(s => s.length > 0);
+}
+class GitCorpusInspector {
+    async headCommit(root) {
+        return (await git(root, ['rev-parse', 'HEAD'])).trim();
+    }
+    async trackedChanges(root) {
+        return nulSeparated(await git(root, ['status', '--porcelain=v1', '-z', '--untracked-files=no']))
+            .map(entry => (/^[ MADRCUT?!]{2} /.test(entry) ? entry.slice(3) : entry));
+    }
+    async untrackedFiles(root, skipDirs) {
+        const excludes = skipDirs.flatMap(d => ['-x', d]);
+        return nulSeparated(await git(root, ['ls-files', '--others', '-z', ...excludes]));
+    }
+    async listFiles(dir) {
+        const out = [];
+        const walk = async (rel) => {
+            let entries;
+            try {
+                entries = await fs.promises.readdir(path.join(dir, rel), { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const e of entries) {
+                const child = rel ? `${rel}/${e.name}` : e.name;
+                if (e.isDirectory())
+                    await walk(child);
+                else
+                    out.push(child);
+            }
+        };
+        await walk('');
+        return out.sort();
+    }
+    async readFile(absPath) {
+        try {
+            return await fs.promises.readFile(absPath);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.GitCorpusInspector = GitCorpusInspector;
+async function isCollectable(file, corpusDir, inspector, ignoreCache) {
+    if ((0, file_utils_1.indexingExclusion)(file, (0, ignore_1.default)()) !== null)
+        return false;
+    const segments = file.split('/');
+    for (let depth = segments.length - 1; depth >= 0; depth--) {
+        const dir = segments.slice(0, depth).join('/');
+        if (!ignoreCache.has(dir)) {
+            const bytes = await inspector.readFile(path.join(corpusDir, dir, RAGIGNORE));
+            ignoreCache.set(dir, bytes === null ? null : (0, ignore_1.default)().add(bytes.toString('utf-8')));
+        }
+        const ig = ignoreCache.get(dir);
+        if (ig && (0, file_utils_1.indexingExclusion)(segments.slice(depth).join('/'), ig) !== null)
+            return false;
+    }
+    return true;
+}
+function listed(files, max = 10) {
+    return files.length <= max ? files.join(', ') : `${files.slice(0, max).join(', ')} and ${files.length - max} more`;
+}
+async function checkCorpus(corpus, corpusDir, keptDir, inspector) {
+    const failures = [];
+    const head = await inspector.headCommit(corpusDir);
+    if (head !== corpus.commit) {
+        failures.push(`checked out at ${head}, suite declares ${corpus.commit}`);
+    }
+    const changed = await inspector.trackedChanges(corpusDir);
+    if (changed.length > 0)
+        failures.push(`tracked files differ from the commit: ${listed(changed)}`);
+    const untracked = await inspector.untrackedFiles(corpusDir, [...file_utils_1.IGNORE_DIRS]);
+    const ignoreCache = new Map();
+    const collectable = [];
+    for (const file of untracked) {
+        if (path.posix.basename(file) === RAGIGNORE)
+            continue;
+        if (await isCollectable(file, corpusDir, inspector, ignoreCache))
+            collectable.push(file);
+    }
+    if (collectable.length > 0)
+        failures.push(`untracked files the indexer would collect: ${listed(collectable)}`);
+    const untrackedIgnores = untracked.filter(f => path.posix.basename(f) === RAGIGNORE).sort();
+    const kept = (await inspector.listFiles(keptDir)).filter(f => path.posix.basename(f) === RAGIGNORE);
+    const keptSet = new Set(kept);
+    const missingCopy = untrackedIgnores.filter(f => !keptSet.has(f));
+    const missingFile = kept.filter(f => !untrackedIgnores.includes(f));
+    if (missingCopy.length > 0)
+        failures.push(`untracked .ragignore with no kept copy: ${listed(missingCopy)}`);
+    if (missingFile.length > 0)
+        failures.push(`kept .ragignore missing from the checkout: ${listed(missingFile)}`);
+    for (const file of untrackedIgnores.filter(f => keptSet.has(f))) {
+        const [actual, copy] = await Promise.all([
+            inspector.readFile(path.join(corpusDir, file)),
+            inspector.readFile(path.join(keptDir, file)),
+        ]);
+        if (actual === null || copy === null || !actual.equals(copy))
+            failures.push(`${file} differs from its kept copy`);
+    }
+    return failures;
+}
+exports.FINGERPRINT_SQL = `SELECT COUNT(*)::int AS chunks,
+       md5(coalesce(string_agg(
+         "serviceName" || E'\\t' || "filePath" || E'\\t' || coalesce("startLine"::text, '') || E'\\t'
+           || md5(content) || E'\\t' || coalesce("ownerPath", '') || E'\\t' || md5(embedding::text),
+         E'\\n' ORDER BY "serviceName" COLLATE "C", "filePath" COLLATE "C", "startLine", md5(content)
+       ), '')) AS fingerprint
+FROM code_chunk
+WHERE "serviceName" = ANY($1::text[])`;
+async function fingerprintCorpus(db, projects) {
+    const [row] = await db.query(exports.FINGERPRINT_SQL, [projects]);
+    return { chunks: Number(row.chunks), fingerprint: row.fingerprint };
+}

package/dist/src/eval-results.d.ts

@@ -1,7 +1,9 @@
-import type { EvalResultFile, CompareResult } from './interfaces/IRetrievalEvaluator';
-/** `yyyy-mm-dd_hh-mm` in local time, matching the existing `benchmarks/results/` naming. */
+import type { EvalResultFile, EvalRunResult, CompareResult, CaseProgress } from './interfaces/IRetrievalEvaluator';
+export declare function degradedNotices(run: EvalRunResult): string[];
+export declare function renderSummary(result: EvalResultFile): string[];
+export declare function renderComparison(baselinePath: string, cmp: CompareResult): string[];
+export declare function renderProgress(p: CaseProgress): string;
 export declare function timestampSlug(date: Date): string;
-/** Writes the JSON + Markdown result files for one eval run; returns their paths. */
 export declare function writeResultFiles(resultsDir: string, suiteLabel: string, result: EvalResultFile, now: Date, comparison?: {
     baselinePath: string;
     result: CompareResult;
@@ -9,4 +11,5 @@ export declare function writeResultFiles(resultsDir: string, suiteLabel: string,
     jsonPath: string;
     mdPath: string;
 };
+export declare function normaliseResultFile(raw: any): EvalResultFile;
 export declare function readResultFile(filePath: string): EvalResultFile;