codesearch-mcp 0.2.2-alpha → 0.3.0-alpha

package/dist/src/declarations/SourceLines.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceLines = void 0;
+const PUNCTUATION_ONLY = /^[}\)\];,]+$/;
+const DIRECTIVE = /^(['"])use [\w -]+\1;?$/;
+const IMPORT_START = /^(import(?=\s*['"{*]|\s+[\w$])|export\s+(\*|type\s+[{*]|\{|import\s+[A-Za-z_$]))/;
+const BARE_IMPORT_NEXT = /^([*{'"]|type\s|[A-Za-z_$][\w$]*\s*(,|from\b|=))/;
+const BARE_IMPORT_LIST = /^[A-Za-z_$][\w$]*\s*,/;
+const MODULE_REFERENCE = /\bfrom\s*(['"]|$)|\brequire\s*\(/;
+const STATEMENT_END = /(['"]|\}|\))\s*;?$|;$|^(export\s+)?import\s+[A-Za-z_$][\w$]*\s*=\s*[A-Za-z_$][\w$.]*$/;
+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 SPECIFIER = String.raw `['"][^'"]+['"]`;
+const NAME = String.raw `(type\s+)?([A-Za-z_$][\w$]*|${SPECIFIER})(\s+as\s+([A-Za-z_$][\w$]*|${SPECIFIER}))?`;
+const ATTRIBUTES = String.raw `(\s+(with|assert)\s*\{[^}]*\}?)?`;
+const CONTINUATION = new RegExp([
+    String.raw `^(\{?\s*${NAME}(\s*,\s*${NAME})*\s*,?\s*)?(\}\s*)?(from(\s+${SPECIFIER}${ATTRIBUTES})?)?\s*;?$`,
+    String.raw `^['"][^'"]*['"]${ATTRIBUTES}\s*;?$`,
+    String.raw `^\)\s*;?$`,
+    String.raw `^\*\s+as\s+[A-Za-z_$][\w$]*(\s+from(\s+${SPECIFIER}${ATTRIBUTES})?)?\s*;?$`,
+    String.raw `^(${SPECIFIER}|[A-Za-z_$][\w$]*)\s*:\s*${SPECIFIER}\s*,?$`,
+].join('|'));
+const MAX_IMPORT_LINE = 100_000;
+const REGEX_PRECEDER = /(^|[(,=:[!&|?{};+\-*%<>~^]|(^|\.\.\.|[^\w$.])(return|typeof|instanceof|in|of|new|delete|void|throw|case|do|else|yield|await))$/;
+const CONDITION_KEYWORDS = new Set(['if', 'while', 'for', 'with']);
+const JSX_OPEN = /^<(>|(?!(const\s+)?[A-Za-z_$][\w$]*\s*(,|extends\b|=|>\s*\())[A-Za-z_$][\w$.:-]*[\s/>{<])/;
+const TYPE_PARAMS_OR_TAG = /^<([A-Za-z_$][\w$]*)\s*>\s*\(/;
+class SourceLines {
+    text;
+    lines;
+    stripped;
+    code;
+    startsInCode;
+    importLines;
+    constructor(text, { jsx = false } = {}) {
+        this.text = text;
+        this.lines = text.split('\n');
+        ({ stripped: this.stripped, startsInCode: this.startsInCode } = SourceLines.scanCode(text, this.lines.length, jsx));
+        this.code = this.stripped.map(l => l.replace(/\s+/g, ''));
+    }
+    get count() {
+        return this.lines.length;
+    }
+    line(n) {
+        return this.lines[n - 1] ?? '';
+    }
+    slice(start, end) {
+        return this.lines.slice(start - 1, end).join('\n');
+    }
+    length(start, end) {
+        return this.slice(start, end).length;
+    }
+    isBlank(n) {
+        return this.line(n).trim() === '';
+    }
+    isCommentOnly(n) {
+        return !this.isBlank(n) && this.code[n - 1] === '';
+    }
+    isDirective(n) {
+        return DIRECTIVE.test(this.stripped[n - 1]?.trim() ?? '');
+    }
+    isPunctuationOnly(n) {
+        return PUNCTUATION_ONLY.test(this.code[n - 1] ?? '');
+    }
+    isSignificant(n) {
+        const code = this.code[n - 1] ?? '';
+        return code !== '' && !PUNCTUATION_ONLY.test(code);
+    }
+    significantLength(start, end) {
+        let n = 0;
+        for (let i = start; i <= end; i++)
+            n += (this.code[i - 1] ?? '').length;
+        return n;
+    }
+    importRegions(start, end) {
+        const regions = [];
+        let i = start;
+        while (i <= end) {
+            const stmtEnd = this.importStatementEnd(i, end);
+            if (stmtEnd === null) {
+                i++;
+                continue;
+            }
+            let regionEnd = stmtEnd;
+            let k = stmtEnd + 1;
+            while (k <= end) {
+                if (this.isBlank(k) || this.isCommentOnly(k)) {
+                    k++;
+                    continue;
+                }
+                const next = this.importStatementEnd(k, end);
+                if (next === null)
+                    break;
+                regionEnd = next;
+                k = next + 1;
+            }
+            regions.push({ start: i, end: regionEnd });
+            i = regionEnd + 1;
+        }
+        return regions;
+    }
+    importStatementEnd(n, limit) {
+        if (!this.startsInCode[n - 1] || !this.startsImport(n, limit))
+            return null;
+        let needsModule = this.stripped[n - 1].trim() === 'import' && BARE_IMPORT_LIST.test(this.nextCode(n, limit));
+        let depth = 0;
+        for (let j = n; j <= limit; j++) {
+            const line = this.stripped[j - 1].trim();
+            if (line === '')
+                continue;
+            if (!SourceLines.isImportLine(line))
+                return null;
+            depth += SourceLines.bracketDepth(line);
+            if (MODULE_REFERENCE.test(line))
+                needsModule = false;
+            if (depth > 0 || !STATEMENT_END.test(line))
+                continue;
+            if (line.endsWith('}') && /^from\b/.test(this.nextCode(j, limit)))
+                continue;
+            return needsModule ? null : j;
+        }
+        return null;
+    }
+    startsImport(n, limit) {
+        const line = this.stripped[n - 1].trim();
+        return IMPORT_START.test(line) || (line === 'import' && BARE_IMPORT_NEXT.test(this.nextCode(n, limit)));
+    }
+    nextCode(n, limit) {
+        for (let j = n + 1; j <= limit; j++) {
+            const line = this.stripped[j - 1].trim();
+            if (line !== '')
+                return line;
+        }
+        return '';
+    }
+    static bracketDepth(line) {
+        let depth = 0;
+        let quote = '';
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            if (quote) {
+                if (ch === '\\')
+                    i++;
+                else if (ch === quote)
+                    quote = '';
+            }
+            else if (ch === '\'' || ch === '"' || ch === '`')
+                quote = ch;
+            else if (ch === '{' || ch === '(')
+                depth++;
+            else if (ch === '}' || ch === ')')
+                depth--;
+        }
+        return depth;
+    }
+    static isImportOrReexportOnly(content) {
+        const src = new SourceLines(content);
+        return src.isImportOnly(1, src.count);
+    }
+    isImportOnly(start, end) {
+        const member = this.importStatementLines();
+        let any = false;
+        for (let n = start; n <= end; n++) {
+            if ((this.code[n - 1] ?? '') === '')
+                continue;
+            if (!member[n - 1])
+                return false;
+            any = true;
+        }
+        return any;
+    }
+    importStatementLines() {
+        if (this.importLines)
+            return this.importLines;
+        const member = Array.from({ length: this.count }, () => false);
+        for (let n = 1; n <= this.count;) {
+            const end = this.importStatementEnd(n, this.count);
+            if (end === null) {
+                n++;
+                continue;
+            }
+            for (let k = n; k <= end; k++)
+                member[k - 1] = true;
+            n = end + 1;
+        }
+        return (this.importLines = member);
+    }
+    static isImportLine(line) {
+        if (line.length > MAX_IMPORT_LINE)
+            return false;
+        for (const [i, statement] of SourceLines.statements(line).entries()) {
+            if (DISQUALIFY.test(statement))
+                return false;
+            if (IMPORT_START.test(statement))
+                continue;
+            if (i === 0 && CONTINUATION.test(statement))
+                continue;
+            return false;
+        }
+        return true;
+    }
+    static statements(line) {
+        const out = [];
+        let from = 0;
+        let quote = '';
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            if (quote) {
+                if (ch === '\\')
+                    i++;
+                else if (ch === quote)
+                    quote = '';
+            }
+            else if (ch === '\'' || ch === '"' || ch === '`')
+                quote = ch;
+            else if (ch === ';') {
+                out.push(line.slice(from, i + 1));
+                from = i + 1;
+            }
+        }
+        out.push(line.slice(from));
+        return out.map(t => t.trim()).filter(t => t !== '' && t !== ';');
+    }
+    static opensElement(text, i) {
+        const head = text.slice(i, i + 64);
+        if (JSX_OPEN.test(head))
+            return true;
+        const name = TYPE_PARAMS_OR_TAG.exec(head)?.[1];
+        return name !== undefined && text.includes(`</${name}>`, i);
+    }
+    static scanCode(text, lineCount, jsx) {
+        const stripped = Array.from({ length: lineCount }, () => '');
+        const startsInCode = Array.from({ length: lineCount }, () => true);
+        let line = 0;
+        let state = 'code';
+        const frames = [{ kind: 'code', braces: 0 }];
+        const parens = [];
+        let afterCondition = false;
+        let word = '';
+        let jsxString = false;
+        let continued = false;
+        let inClass = false;
+        let tail = '';
+        const emit = (chars) => {
+            stripped[line] += chars;
+            tail = (tail + chars.replace(/\s+/g, '')).slice(-16);
+        };
+        for (let i = 0; i < text.length; i++) {
+            const ch = text[i];
+            const next = text[i + 1];
+            const frame = frames[frames.length - 1];
+            if (ch === '\n') {
+                line++;
+                if (state === 'line' || state === 'regex')
+                    state = 'code';
+                if ((state === '\'' || state === '"') && !jsxString && !continued)
+                    state = 'code';
+                continued = false;
+                if (line < lineCount)
+                    startsInCode[line] = state === 'code' && frame.kind === 'code';
+                continue;
+            }
+            switch (state) {
+                case 'line':
+                    continue;
+                case 'block':
+                    if (ch === '*' && next === '/') {
+                        state = 'code';
+                        i++;
+                    }
+                    continue;
+                case '\'':
+                case '"':
+                    if (!jsxString && ch === '\\' && next !== undefined) {
+                        continued = next === '\n' || (next === '\r' && text[i + 2] === '\n');
+                        if (next === '\n') {
+                            emit(ch);
+                            continue;
+                        }
+                        emit(ch + next);
+                        i++;
+                        continue;
+                    }
+                    if (ch === state)
+                        state = 'code';
+                    emit(ch);
+                    continue;
+                case 'regex':
+                    if (ch === '\\' && next !== undefined && next !== '\n') {
+                        emit(ch + next);
+                        i++;
+                        continue;
+                    }
+                    if (inClass) {
+                        if (ch === ']')
+                            inClass = false;
+                    }
+                    else if (ch === '[')
+                        inClass = true;
+                    else if (ch === '/')
+                        state = 'code';
+                    emit(ch);
+                    continue;
+            }
+            switch (frame.kind) {
+                case 'template':
+                    if (ch === '\\' && next !== undefined && next !== '\n') {
+                        emit(ch + next);
+                        i++;
+                        continue;
+                    }
+                    if (ch === '`')
+                        frames.pop();
+                    else if (ch === '$' && next === '{') {
+                        frames.push({ kind: 'code', braces: 0 });
+                        emit('${');
+                        i++;
+                        continue;
+                    }
+                    emit(ch);
+                    continue;
+                case 'children':
+                    if (ch === '{')
+                        frames.push({ kind: 'code', braces: 0 });
+                    else if (ch === '<' && next === '/') {
+                        frames.push({ kind: 'tag', closing: true, angles: 0 });
+                        emit('</');
+                        i++;
+                        continue;
+                    }
+                    else if (ch === '<')
+                        frames.push({ kind: 'tag', closing: false, angles: 0 });
+                    emit(ch);
+                    continue;
+                case 'tag':
+                    if (ch === '/' && next === '/') {
+                        state = 'line';
+                        i++;
+                        continue;
+                    }
+                    if (ch === '/' && next === '*') {
+                        state = 'block';
+                        emit(' ');
+                        i++;
+                        continue;
+                    }
+                    if (ch === '/' && next === '>') {
+                        frames.pop();
+                        emit('/>');
+                        i++;
+                        continue;
+                    }
+                    if (ch === '\'' || ch === '"') {
+                        state = ch;
+                        jsxString = true;
+                    }
+                    else if (ch === '{')
+                        frames.push({ kind: 'code', braces: 0 });
+                    else if (ch === '<')
+                        frame.angles++;
+                    else if (ch === '>' && frame.angles > 0)
+                        frame.angles--;
+                    else if (ch === '>') {
+                        frames.pop();
+                        if (frame.closing)
+                            frames.pop();
+                        else
+                            frames.push({ kind: 'children' });
+                    }
+                    emit(ch);
+                    continue;
+            }
+            if (ch === '/' && next === '/') {
+                state = 'line';
+                i++;
+                continue;
+            }
+            if (ch === '/' && next === '*') {
+                state = 'block';
+                emit(' ');
+                i++;
+                continue;
+            }
+            if (ch === '/' && (afterCondition || REGEX_PRECEDER.test(tail))) {
+                state = 'regex';
+                inClass = false;
+            }
+            else if (ch === '\'' || ch === '"') {
+                state = ch;
+                jsxString = false;
+            }
+            else if (ch === '`')
+                frames.push({ kind: 'template' });
+            else if (ch === '{')
+                frame.braces++;
+            else if (ch === '}' && frame.braces > 0)
+                frame.braces--;
+            else if (ch === '}' && frames.length > 1)
+                frames.pop();
+            else if (ch === '(')
+                parens.push(CONDITION_KEYWORDS.has(word));
+            else if (jsx && ch === '<' && !tail.endsWith('<') && REGEX_PRECEDER.test(tail) && SourceLines.opensElement(text, i)) {
+                frames.push({ kind: 'tag', closing: false, angles: 0 });
+            }
+            if (/[\w$]/.test(ch))
+                word = /[\w$]/.test(text[i - 1] ?? '') ? word + ch : ch;
+            else if (!/\s/.test(ch))
+                word = '';
+            if (!/\s/.test(ch))
+                afterCondition = ch === ')' && (parens.pop() ?? false);
+            emit(ch);
+        }
+        return { stripped, startsInCode };
+    }
+}
+exports.SourceLines = SourceLines;

package/dist/src/dependency-traversal.d.ts

@@ -0,0 +1,10 @@
+export interface Edge {
+    from: string;
+    to: string;
+}
+export interface IndirectRow {
+    file: string;
+    depth: number;
+    via: string;
+}
+export declare function traverse(root: string, neighbours: (frontier: string[]) => Promise<Edge[]>, maxDepth?: number): Promise<IndirectRow[]>;

package/dist/src/dependency-traversal.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverse = traverse;
+function byteCompare(a, b) {
+    return Buffer.compare(Buffer.from(a, 'utf8'), Buffer.from(b, 'utf8'));
+}
+async function traverse(root, neighbours, maxDepth = 20) {
+    const visited = new Map();
+    visited.set(root, 0);
+    const via = new Map();
+    let frontier = [root];
+    let depth = 1;
+    while (frontier.length > 0 && depth <= maxDepth) {
+        const edges = await neighbours(frontier);
+        const bestVia = new Map();
+        for (const edge of edges) {
+            if (visited.has(edge.to))
+                continue;
+            const current = bestVia.get(edge.to);
+            if (current === undefined || byteCompare(edge.from, current) < 0)
+                bestVia.set(edge.to, edge.from);
+        }
+        const next = [];
+        for (const [to, from] of bestVia) {
+            visited.set(to, depth);
+            via.set(to, from);
+            next.push(to);
+        }
+        frontier = next;
+        depth += 1;
+    }
+    const rows = [];
+    for (const [file, d] of visited) {
+        if (d >= 2)
+            rows.push({ file, depth: d, via: via.get(file) });
+    }
+    rows.sort((a, b) => a.depth - b.depth || byteCompare(a.file, b.file));
+    return rows;
+}

package/dist/src/enriched-prompt.d.ts

@@ -1,8 +1,3 @@
 import type { ChunkPiece } from './interfaces/IChunker';
 import type { DepEdge, SymbolEntry } from './interfaces/IAstParser';
-/**
- * Build the embedding-input prompt for one chunk. `symbols` is the file's
- * top-level declarations only (never members) — the prompt is unaffected by
- * this change (see the `symbol-index-members` non-goal).
- */
 export declare function getEnrichedPrompt(piece: ChunkPiece, relPath: string, serviceName: string, edges: DepEdge[], symbols: SymbolEntry[]): string;

package/dist/src/enriched-prompt.js

@@ -59,11 +59,6 @@ function inferRole(relPath) {
         return 'Utility';
     return null;
 }
-/**
- * Build the embedding-input prompt for one chunk. `symbols` is the file's
- * top-level declarations only (never members) — the prompt is unaffected by
- * this change (see the `symbol-index-members` non-goal).
- */
 function getEnrichedPrompt(piece, relPath, serviceName, edges, symbols) {
     const chunkStart = piece.startLine;
     const chunkEnd = piece.endLine;

package/dist/src/error-record.d.ts

@@ -0,0 +1,12 @@
+export declare const MAX_CAUSES = 5;
+export declare const MAX_FRAMES = 30;
+export declare const MAX_QUERY_CHARS = 500;
+export declare const MAX_PARAMS = 30;
+export declare const MAX_PARAM_CHARS = 120;
+export declare const MAX_AGGREGATED = 10;
+export declare function serializeError(value: unknown): unknown;
+export declare function rootCauseMessage(value: unknown): string;
+export declare function errorMessage(value: unknown): string;
+export declare const LOG_SERIALIZERS: {
+    err: typeof serializeError;
+};