codesearch-mcp 0.0.18-alpha → 0.1.0-alpha

package/dist/src/searcher.js

@@ -1,446 +0,0 @@
-"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.prepareQuery = prepareQuery;
-exports.listProjects = listProjects;
-exports.searchChunks = searchChunks;
-exports.fetchNeighbors = fetchNeighbors;
-exports.getDependencies = getDependencies;
-exports.getDependents = getDependents;
-exports.grepSymbol = grepSymbol;
-exports.findSymbol = findSymbol;
-exports.listFiles = listFiles;
-exports.readFileAbsolute = readFileAbsolute;
-exports.readFileRange = readFileRange;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const readline = __importStar(require("readline"));
-const child_process_1 = require("child_process");
-const db_1 = require("./db");
-const config_1 = require("./config");
-const ollama_1 = require("./ollama");
-const file_utils_1 = require("./file-utils");
-// Detect non-English input by presence of non-ASCII characters (Cyrillic, etc.)
-function isNonEnglish(text) {
-    return /[^\x00-\x7F]/.test(text);
-}
-// Translate query to English using a local Ollama model
-async function translateToEnglish(text) {
-    const response = await ollama_1.ollama.chat({
-        model: config_1.config.search.translateModel,
-        messages: [{ role: 'user', content: `Translate the following text to English. Return only the translation, no explanations:\n${text}` }],
-    });
-    return response.message.content.trim();
-}
-// Translate if AUTO_TRANSLATE is enabled and input is non-English
-async function prepareQuery(raw) {
-    if (config_1.config.search.autoTranslate && isNonEnglish(raw)) {
-        return { query: await translateToEnglish(raw), translated: true };
-    }
-    return { query: raw, translated: false };
-}
-const EMPTY_META = { description: null, stack: null, notes: null, relations: null };
-async function listProjects() {
-    const rows = await db_1.db.query(`SELECT "serviceName", COUNT(*)::int AS chunks
-     FROM code_chunk
-     GROUP BY "serviceName"
-     ORDER BY "serviceName"`);
-    return rows.map(r => ({
-        ...r,
-        ...((0, file_utils_1.readRagMeta)(path.join(config_1.config.workspaceRoot, r.serviceName)) ?? EMPTY_META),
-    }));
-}
-// Embed query and run vector similarity search
-async function searchChunks(query, limit, project) {
-    const { embedding } = await ollama_1.ollama.embeddings({ model: config_1.config.ollama.model, prompt: query });
-    const params = [`[${embedding}]`, config_1.config.search.similarityThreshold, limit];
-    let projectFilter = '';
-    if (project) {
-        params.push(project);
-        projectFilter = `AND "serviceName" = $${params.length}`;
-    }
-    // Cast score to float8 so TypeORM returns a number, not a string
-    return db_1.db.query(`SELECT "serviceName", "filePath", "startLine", content,
-            ROUND((embedding <=> $1)::numeric, 4)::float8 AS score
-     FROM code_chunk
-     WHERE embedding <=> $1 < $2
-     ${projectFilter}
-     ORDER BY embedding <=> $1
-     LIMIT $3`, params);
-}
-// Fetch the chunk immediately before and after each result in the same file (Small-to-Big).
-// Single query with LATERAL joins — avoids 2N round-trips.
-async function fetchNeighbors(results) {
-    if (results.length === 0)
-        return [];
-    const values = results.map((_, i) => `(${i}, $${i * 2 + 1}, $${i * 2 + 2}::int)`).join(',');
-    const params = results.flatMap(r => [r.filePath, r.startLine]);
-    const rows = await db_1.db.query(`SELECT r.idx,
-            prev."serviceName" AS prev_sn, prev."filePath" AS prev_fp, prev."startLine" AS prev_sl, prev.content AS prev_c,
-            next."serviceName" AS next_sn, next."filePath" AS next_fp, next."startLine" AS next_sl, next.content AS next_c
-     FROM (VALUES ${values}) r(idx, fp, sl)
-     LEFT JOIN LATERAL (
-       SELECT "serviceName", "filePath", "startLine", content
-       FROM code_chunk WHERE "filePath" = r.fp AND "startLine" < r.sl
-       ORDER BY "startLine" DESC LIMIT 1
-     ) prev ON true
-     LEFT JOIN LATERAL (
-       SELECT "serviceName", "filePath", "startLine", content
-       FROM code_chunk WHERE "filePath" = r.fp AND "startLine" > r.sl
-       ORDER BY "startLine" ASC LIMIT 1
-     ) next ON true
-     ORDER BY r.idx`, params);
-    return rows.map((row, i) => ({
-        result: results[i],
-        prevChunk: row.prev_fp ? { serviceName: row.prev_sn, filePath: row.prev_fp, startLine: row.prev_sl, content: row.prev_c } : null,
-        nextChunk: row.next_fp ? { serviceName: row.next_sn, filePath: row.next_fp, startLine: row.next_sl, content: row.next_c } : null,
-    }));
-}
-// Return all files imported by filePath (direct or transitive)
-async function getDependencies(filePath, project, symbol = null, transitive = false) {
-    const params = [filePath, project];
-    let symbolFilter = '';
-    if (symbol) {
-        params.push(symbol);
-        symbolFilter = `AND "toSymbol" = $${params.length}`;
-    }
-    const direct = await db_1.db.query(`SELECT "fromFile", "fromSymbol", "toFile", "toSymbol", "depType"
-     FROM code_dependency
-     WHERE "fromFile" = $1 AND project = $2
-     ${symbolFilter}
-     ORDER BY "toFile"`, params);
-    if (!transitive)
-        return direct;
-    // Indirect: depth>1 only, deduplicated by toFile (symbols dropped for clarity)
-    const indirect = await db_1.db.query(`WITH RECURSIVE deps AS (
-       SELECT "toFile", 1 AS depth, "toFile" AS via
-       FROM code_dependency
-       WHERE "fromFile" = $1 AND project = $2
-
-       UNION
-
-       SELECT d."toFile", deps.depth + 1, deps."toFile" AS via
-       FROM code_dependency d
-       JOIN deps ON deps."toFile" = d."fromFile"
-       WHERE d.project = $2
-         AND d."toFile" <> $1
-         AND deps.depth < 20
-     )
-     SELECT "toFile", MIN(depth) AS depth,
-            (array_agg(via ORDER BY depth))[1] AS via,
-            NULL::text AS "fromFile", NULL::text AS "fromSymbol",
-            NULL::text AS "toSymbol", NULL::text AS "depType"
-     FROM deps
-     WHERE depth > 1
-     GROUP BY "toFile"
-     ORDER BY MIN(depth), "toFile"`, [filePath, project]);
-    return [...direct, ...indirect];
-}
-// Return all files that import filePath (direct or transitive)
-async function getDependents(filePath, project, symbol = null, transitive = false) {
-    const params = [filePath, project];
-    let symbolFilter = '';
-    if (symbol) {
-        params.push(symbol);
-        symbolFilter = `AND "toSymbol" = $${params.length}`;
-    }
-    const direct = await db_1.db.query(`SELECT "fromFile", "fromSymbol", "toFile", "toSymbol", "depType"
-     FROM code_dependency
-     WHERE "toFile" = $1 AND project = $2
-     ${symbolFilter}
-     ORDER BY "fromFile"`, params);
-    if (!transitive)
-        return direct;
-    // Indirect: depth>1 only, deduplicated by fromFile
-    const indirect = await db_1.db.query(`WITH RECURSIVE rdeps AS (
-       SELECT "fromFile", 1 AS depth, "fromFile" AS via
-       FROM code_dependency
-       WHERE "toFile" = $1 AND project = $2
-
-       UNION
-
-       SELECT d."fromFile", rdeps.depth + 1, rdeps."fromFile" AS via
-       FROM code_dependency d
-       JOIN rdeps ON rdeps."fromFile" = d."toFile"
-       WHERE d.project = $2
-         AND d."fromFile" <> $1
-         AND rdeps.depth < 20
-     )
-     SELECT "fromFile", MIN(depth) AS depth,
-            (array_agg(via ORDER BY depth))[1] AS via,
-            NULL::text AS "toFile", NULL::text AS "fromSymbol",
-            NULL::text AS "toSymbol", NULL::text AS "depType"
-     FROM rdeps
-     WHERE depth > 1
-     GROUP BY "fromFile"
-     ORDER BY MIN(depth), "fromFile"`, [filePath, project]);
-    return [...direct, ...indirect];
-}
-const GREP_MAX_RESULTS = 200;
-// Grep stops after this many raw lines; generous multiple of GREP_MAX_RESULTS to account for
-// the declaring file's own matches being excluded from the final count.
-const GREP_RAW_LIMIT = GREP_MAX_RESULTS * 5;
-const GREP_EXCLUDE_DIRS = [...file_utils_1.IGNORE_DIRS].map(d => `--exclude-dir=${d}`);
-// Text search for a symbol across all TS/JS files in the project directory.
-// Uses grep -F -w (literal whole-word match) via spawnSync to avoid shell injection.
-// Excludes the declaring file itself. Uses IGNORE_DIRS for consistency with the indexer.
-function grepSymbol(symbol, project, excludeFile) {
-    const projectDir = path.join(config_1.config.workspaceRoot, project);
-    const result = (0, child_process_1.spawnSync)('grep', [
-        '-rn', '-F', '-w',
-        '-m', String(GREP_RAW_LIMIT),
-        '--include=*.ts', '--include=*.tsx', '--include=*.js', '--include=*.jsx',
-        ...GREP_EXCLUDE_DIRS,
-        symbol,
-        projectDir,
-    ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-    if (result.error || !result.stdout) {
-        if (result.error)
-            console.error(`[grepSymbol] grep failed: ${result.error.message}`);
-        return { matches: [], truncated: false };
-    }
-    const excludeAbsPath = path.join(config_1.config.workspaceRoot, excludeFile);
-    const all = result.stdout.split('\n').flatMap(line => {
-        const match = line.match(/^(.+?):(\d+):/);
-        if (!match)
-            return [];
-        const [, absFile, lineNum] = match;
-        if (absFile === excludeAbsPath)
-            return [];
-        return [{ filePath: path.relative(config_1.config.workspaceRoot, absFile), line: parseInt(lineNum, 10) }];
-    });
-    return { matches: all.slice(0, GREP_MAX_RESULTS), truncated: all.length > GREP_MAX_RESULTS };
-}
-const FIND_SYMBOL_LIMIT = 50;
-const FIND_SYMBOL_RAW_LIMIT = FIND_SYMBOL_LIMIT * 10;
-function buildFindSymbolPattern(name, kind) {
-    const patterns = {
-        function: `(export[[:space:]]+)?(async[[:space:]]+)?function[[:space:]]+${name}[[:space:](<]`,
-        class: `(export[[:space:]]+)?(abstract[[:space:]]+)?class[[:space:]]+${name}[[:space:]{<]`,
-        type: `(export[[:space:]]+)?type[[:space:]]+${name}[[:space:]=<]`,
-        interface: `(export[[:space:]]+)?interface[[:space:]]+${name}[[:space:]{<]`,
-        variable: `(export[[:space:]]+)?(const|let|var)[[:space:]]+${name}[[:space:]=:]`,
-    };
-    if (kind === 'all')
-        return Object.values(patterns).join('|');
-    return patterns[kind];
-}
-function inferKind(line, name) {
-    const before = line.slice(0, line.indexOf(name));
-    if (/\bfunction\s+$/.test(before))
-        return 'function';
-    if (/\bclass\s+$/.test(before))
-        return 'class';
-    if (/\binterface\s+$/.test(before))
-        return 'interface';
-    if (/\btype\s+$/.test(before))
-        return 'type';
-    return 'variable';
-}
-function findSymbol(name, project, kind) {
-    if (!/^[\w$]+$/.test(name))
-        throw new Error('Invalid symbol name');
-    const searchDir = project
-        ? path.join(config_1.config.workspaceRoot, project)
-        : config_1.config.workspaceRoot;
-    const pattern = buildFindSymbolPattern(name, kind);
-    const result = (0, child_process_1.spawnSync)('grep', [
-        '-rn', '-E',
-        '-m', String(FIND_SYMBOL_RAW_LIMIT),
-        '--include=*.ts', '--include=*.tsx', '--include=*.js', '--include=*.jsx',
-        ...GREP_EXCLUDE_DIRS,
-        pattern,
-        searchDir,
-    ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-    if (result.error) {
-        console.error(`[findSymbol] grep failed: ${result.error.message}`);
-        return { hits: [], truncated: false };
-    }
-    if (!result.stdout)
-        return { hits: [], truncated: false };
-    const hits = [];
-    for (const raw of result.stdout.split('\n')) {
-        if (hits.length >= FIND_SYMBOL_LIMIT)
-            break;
-        // grep -n format: "/abs/path/file.ts:42:   export function Foo(...)"
-        // File paths can contain colons on some systems, so split carefully:
-        // find first colon after a path separator, use lastIndexOf on the line number part
-        const m = raw.match(/^(.+?):(\d+):(.*)$/);
-        if (!m)
-            continue;
-        const [, absFile, lineNumStr, matchedLine] = m;
-        const lineNum = parseInt(lineNumStr, 10);
-        if (isNaN(lineNum))
-            continue;
-        const col = matchedLine.indexOf(name);
-        if (col === -1)
-            continue;
-        hits.push({
-            filePath: path.relative(config_1.config.workspaceRoot, absFile),
-            line: lineNum,
-            column: col + 1,
-            kind: inferKind(matchedLine, name),
-            signature: matchedLine.trim(),
-        });
-    }
-    return { hits, truncated: hits.length >= FIND_SYMBOL_LIMIT };
-}
-// ── list_files ────────────────────────────────────────────────────────────────
-function walkDir(absDir, currentDepth, maxDepth, pattern, lines) {
-    let entries;
-    try {
-        entries = fs.readdirSync(absDir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    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()) {
-            lines.push(`${indent}${entry.name}/`);
-            if (currentDepth < maxDepth) {
-                walkDir(path.join(absDir, entry.name), currentDepth + 1, maxDepth, pattern, lines);
-            }
-        }
-        else {
-            if (pattern && !entry.name.includes(pattern))
-                continue;
-            lines.push(`${indent}${entry.name}`);
-        }
-    }
-}
-function listFiles(relativePath, project, depth, pattern) {
-    const projectRoot = path.join(config_1.config.workspaceRoot, project);
-    const resolvedTarget = path.resolve(projectRoot, relativePath);
-    const resolvedProject = path.resolve(projectRoot);
-    if (resolvedTarget !== resolvedProject && !resolvedTarget.startsWith(resolvedProject + path.sep)) {
-        return { tree: '', error: 'Path escapes project root' };
-    }
-    if (!fs.existsSync(resolvedTarget)) {
-        return { tree: '', error: `Path not found: ${relativePath}` };
-    }
-    if (!fs.statSync(resolvedTarget).isDirectory()) {
-        return { tree: '', error: `Not a directory: ${relativePath}` };
-    }
-    const clampedDepth = Math.min(5, Math.max(1, depth));
-    const lines = [];
-    walkDir(resolvedTarget, 0, clampedDepth - 1, pattern, lines);
-    if (lines.length === 0) {
-        return { tree: pattern ? `No files matching "${pattern}" found.` : '(empty directory)' };
-    }
-    return { tree: lines.join('\n') };
-}
-// ── readFileAbsolute ──────────────────────────────────────────────────────────
-// Variant of readFileRange that accepts an absolute path and skips the DB index check.
-// Used by the read_file MCP tool, which receives absolute paths from search_codebase.
-async function readFileAbsolute(absPath, maxLines) {
-    const resolvedRoot = path.resolve(config_1.config.workspaceRoot);
-    const resolved = path.resolve(absPath);
-    if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + path.sep)) {
-        return { ok: false, reason: 'invalid_path' };
-    }
-    if (!fs.existsSync(resolved))
-        return { ok: false, reason: 'not_on_disk' };
-    const lines = [];
-    const stream = fs.createReadStream(resolved, { encoding: 'utf-8' });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-    let lineNo = 0;
-    let hasMore = false;
-    try {
-        for await (const line of rl) {
-            lineNo++;
-            if (lineNo <= maxLines)
-                lines.push(line);
-            if (lineNo >= maxLines) {
-                hasMore = true;
-                rl.close();
-                stream.destroy();
-                break;
-            }
-        }
-    }
-    catch (err) {
-        rl.close();
-        stream.destroy();
-        throw err;
-    }
-    const relPath = path.relative(resolvedRoot, resolved);
-    return { ok: true, filePath: relPath, startLine: 1, endLine: lineNo, lines, hasMore };
-}
-// Read a line range from a file that is present in the index
-async function readFileRange(filePath, startLine, endLine) {
-    // Defensive: reject paths that escape the workspace root (e.g. "../../etc/passwd")
-    const resolvedRoot = path.resolve(config_1.config.workspaceRoot);
-    const absPath = path.resolve(resolvedRoot, filePath);
-    if (absPath !== resolvedRoot && !absPath.startsWith(resolvedRoot + path.sep)) {
-        return { ok: false, reason: 'invalid_path' };
-    }
-    const [{ exists }] = await db_1.db.query(`SELECT EXISTS (SELECT 1 FROM code_chunk WHERE "filePath" = $1) AS exists`, [filePath]);
-    if (!exists)
-        return { ok: false, reason: 'not_indexed' };
-    if (!fs.existsSync(absPath))
-        return { ok: false, reason: 'not_on_disk' };
-    // Stream line-by-line — avoids loading entire file into memory.
-    // Stops reading as soon as we pass endLine.
-    const lines = [];
-    const stream = fs.createReadStream(absPath, { encoding: 'utf-8' });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-    let lineNo = 0;
-    let lastRead = 0;
-    let hasMore = false;
-    for await (const line of rl) {
-        lineNo++;
-        lastRead = lineNo;
-        if (lineNo >= startLine && lineNo <= endLine)
-            lines.push(line);
-        if (lineNo >= endLine) {
-            hasMore = true;
-            rl.close();
-            stream.destroy();
-            break;
-        }
-    }
-    // If we broke out early, lastRead is endLine. If file was shorter, lastRead is file length.
-    return { ok: true, filePath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
-}

package/dist/vitest.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: UserConfig;
-export default _default;

package/dist/vitest.config.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const config_1 = require("vitest/config");
-exports.default = (0, config_1.defineConfig)({
-    test: {
-        environment: 'node',
-        include: ['tests/**/*.test.ts'],
-    },
-});