codesearch-mcp 0.0.9-alpha → 0.0.10-alpha

package/dist/src/services/SearcherService.js

@@ -0,0 +1,453 @@
+"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.SearcherService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const child_process_1 = require("child_process");
+const file_utils_1 = require("../file-utils");
+const LoggerService_1 = require("./LoggerService");
+const EMPTY_META = { description: null, stack: null, notes: null, relations: null };
+const GREP_MAX_RESULTS = 200;
+const GREP_RAW_LIMIT = GREP_MAX_RESULTS * 5;
+const GREP_EXCLUDE_DIRS = [...file_utils_1.IGNORE_DIRS].map(d => `--exclude-dir=${d}`);
+const FIND_SYMBOL_LIMIT = 50;
+const FIND_SYMBOL_RAW_LIMIT = FIND_SYMBOL_LIMIT * 10;
+class SearcherService {
+    db;
+    embedder;
+    config;
+    logger;
+    constructor(db, embedder, config, logger = LoggerService_1.LoggerService.silent()) {
+        this.db = db;
+        this.embedder = embedder;
+        this.config = config;
+        this.logger = logger;
+    }
+    async prepareQuery(raw) {
+        if (this.config.search.autoTranslate && this.isNonEnglish(raw) && this.embedder.translate) {
+            return { query: await this.embedder.translate(raw, this.config.search.translateModel), translated: true };
+        }
+        return { query: raw, translated: false };
+    }
+    async listProjects() {
+        const rows = await this.db.query(`SELECT "serviceName", COUNT(*)::int AS chunks
+       FROM code_chunk
+       GROUP BY "serviceName"
+       ORDER BY "serviceName"`);
+        return rows.map(r => {
+            const meta = (0, file_utils_1.readRagMeta)(path.join(this.config.workspaceRoot, r.serviceName));
+            return { ...r, ...(typeof meta === 'object' ? meta : EMPTY_META) };
+        });
+    }
+    async searchChunks(query, limit, project) {
+        const embedding = await this.embedder.embed(query);
+        const params = [`[${embedding}]`, this.config.search.similarityThreshold, limit];
+        let projectFilter = '';
+        if (project) {
+            params.push(project);
+            projectFilter = `AND "serviceName" = $${params.length}`;
+        }
+        return this.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);
+    }
+    async 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 this.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,
+        }));
+    }
+    async 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 this.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;
+        const indirect = await this.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];
+    }
+    async 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 this.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;
+        const indirect = await this.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];
+    }
+    grepSymbol(symbol, project, excludeFile) {
+        const projectDir = path.join(this.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)
+                this.logger.error('SearcherService: grep failed', { method: 'grepSymbol', reason: result.error.message });
+            return { matches: [], truncated: false };
+        }
+        const excludeAbsPath = path.join(this.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(this.config.workspaceRoot, absFile), line: parseInt(lineNum, 10) }];
+        });
+        return { matches: all.slice(0, GREP_MAX_RESULTS), truncated: all.length > GREP_MAX_RESULTS };
+    }
+    // Sync wrapper: validates name (throws synchronously), then returns Promise.
+    // Falls back to grep when the symbol index (code_symbol table) is unavailable.
+    findSymbol(name, project, kind) {
+        if (!/^[\w$]+$/.test(name))
+            throw new Error('Invalid symbol name');
+        return this.findSymbolFromIndex(name, project, kind);
+    }
+    async findSymbolFromIndex(name, project, kind) {
+        try {
+            const params = [name];
+            let projectFilter = '';
+            if (project) {
+                params.push(project);
+                projectFilter = `AND project = $${params.length}`;
+            }
+            let kindFilter = '';
+            if (kind !== 'all') {
+                params.push(kind);
+                kindFilter = `AND kind = $${params.length}`;
+            }
+            params.push(FIND_SYMBOL_LIMIT + 1);
+            const rows = await this.db.query(`SELECT "filePath", name, kind, signature, line, col
+           FROM code_symbol
+           WHERE name = $1 ${projectFilter} ${kindFilter}
+           ORDER BY project, "filePath"
+           LIMIT $${params.length}`, params);
+            const truncated = rows.length > FIND_SYMBOL_LIMIT;
+            const hits = rows.slice(0, FIND_SYMBOL_LIMIT).map(row => ({
+                filePath: row.filePath,
+                line: row.line ?? 1,
+                column: row.col ?? 1,
+                kind: row.kind,
+                signature: row.signature ?? row.name,
+            }));
+            return { hits, truncated };
+        }
+        catch {
+            this.logger.warn('SearcherService: symbol index unavailable, falling back to grep', { name, project });
+            return this.grepFindSymbol(name, project, kind);
+        }
+    }
+    grepFindSymbol(name, project, kind) {
+        const searchDir = project
+            ? path.join(this.config.workspaceRoot, project)
+            : this.config.workspaceRoot;
+        const pattern = this.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) {
+            this.logger.error('SearcherService: grep failed', { method: 'findSymbol', reason: 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;
+            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(this.config.workspaceRoot, absFile),
+                line: lineNum,
+                column: col + 1,
+                kind: this.inferKind(matchedLine, name),
+                signature: matchedLine.trim(),
+            });
+        }
+        return { hits, truncated: hits.length >= FIND_SYMBOL_LIMIT };
+    }
+    listFiles(relativePath, project, depth, pattern) {
+        const projectRoot = path.join(this.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 = [];
+        this.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') };
+    }
+    async readFileAbsolute(absPath, maxLines) {
+        const resolvedRoot = path.resolve(this.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);
+                }
+                else {
+                    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: lines.length, lines, hasMore };
+    }
+    async readFileRange(filePath, startLine, endLine) {
+        const resolvedRoot = path.resolve(this.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 this.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' };
+        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++;
+            if (lineNo >= startLine && lineNo <= endLine)
+                lines.push(line);
+            if (lineNo <= endLine)
+                lastRead = lineNo;
+            if (lineNo > endLine) {
+                hasMore = true;
+                rl.close();
+                stream.destroy();
+                break;
+            }
+        }
+        return { ok: true, filePath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
+    }
+    isNonEnglish(text) {
+        return /[^\x00-\x7F]/.test(text);
+    }
+    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) {
+                    this.walkDir(path.join(absDir, entry.name), currentDepth + 1, maxDepth, pattern, lines);
+                }
+            }
+            else {
+                if (pattern && !entry.name.includes(pattern))
+                    continue;
+                lines.push(`${indent}${entry.name}`);
+            }
+        }
+    }
+    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];
+    }
+    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';
+    }
+}
+exports.SearcherService = SearcherService;

package/dist/src/setup.js

@@ -132,7 +132,7 @@ async function setupLocalDocker(ollamaHost) {
         console.error('Failed to start Docker containers. Make sure Docker is running.');
         process.exit(1);
     }
-    await waitForDb('localhost', 5433, 'dev', 'dev', 'rag');
+    await waitForDb('localhost', 5433, 'dev', 'dev', 'postgres');
     await waitForOllama(ollamaHost);
     // Resolve the ollama container ID via compose — compose project name (and thus the
     // default container name) depends on the parent directory, so hardcoding it breaks when
@@ -151,7 +151,6 @@ async function setupLocalDocker(ollamaHost) {
         DB_PORT: '5433',
         DB_USER: 'dev',
         DB_PASS: 'dev',
-        DB_NAME: 'rag',
     };
 }
 async function setupRemoteDb(rl) {
@@ -161,9 +160,8 @@ async function setupRemoteDb(rl) {
         vars.DB_PORT = await prompt(rl, 'DB port', '5432');
         vars.DB_USER = await prompt(rl, 'DB user', 'postgres');
         vars.DB_PASS = await prompt(rl, 'DB password', '');
-        vars.DB_NAME = await prompt(rl, 'DB name', 'rag');
         console.log('\nTesting connection...');
-        const ok = await checkRemoteDb(vars.DB_HOST, vars.DB_PORT, vars.DB_USER, vars.DB_PASS, vars.DB_NAME);
+        const ok = await checkRemoteDb(vars.DB_HOST, vars.DB_PORT, vars.DB_USER, vars.DB_PASS, 'postgres');
         if (ok) {
             console.log('Connection successful.');
             break;
@@ -186,20 +184,38 @@ async function runSetup() {
     const dbVars = useDocker
         ? await setupLocalDocker(ollamaHost)
         : await setupRemoteDb(rl);
+    console.log('\n--- Logging ---');
+    console.log('  error  — failures only (recommended)');
+    console.log('  warn   — + recoverable issues');
+    console.log('  debug  — full diagnostic output (verbose)');
+    const validLevels = ['error', 'warn', 'info', 'debug'];
+    let logLevel;
+    do {
+        logLevel = await prompt(rl, 'Log level (error/warn/info/debug)', 'error');
+        if (!validLevels.includes(logLevel))
+            console.log(`  Invalid level. Choose: ${validLevels.join(', ')}`);
+    } while (!validLevels.includes(logLevel));
+    const defaultLogFile = path.join(os.homedir(), '.config', 'codesearch-mcp', 'rag.log');
+    const logFileInput = await ask(rl, `Log file (${defaultLogFile}, or "false" to disable): `);
+    const logFile = logFileInput.trim() || defaultLogFile;
     writeEnv({
         ...dbVars,
         WORKSPACE_ROOT: workspaceRoot,
         OLLAMA_HOST: ollamaHost,
+        LOG_LEVEL: logLevel,
+        LOG_FILE: logFile,
     });
     rl.close();
     console.log('\nInitializing database schema...');
     const dotenv = await Promise.resolve().then(() => __importStar(require('dotenv')));
     dotenv.config({ path: CONFIG_FILE, override: true });
-    const { initDbWithSchema } = await Promise.resolve().then(() => __importStar(require('./db')));
-    await initDbWithSchema();
+    const { config } = await Promise.resolve().then(() => __importStar(require('./config')));
+    const { DatabaseService } = await Promise.resolve().then(() => __importStar(require('./services/DatabaseService')));
+    const dbService = new DatabaseService(config);
+    await dbService.initDbWithSchema();
+    await dbService.destroy();
     console.log('\nSetup complete!');
     console.log('\nNext steps:');
     console.log(`  rag-index ${workspaceRoot}`);
     console.log('  claude mcp add codesearch-mcp -s user -- rag-mcp');
-    process.exit(0);
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "codesearch-mcp",
-  "version": "0.0.9-alpha",
+  "version": "0.0.10-alpha",
   "description": "Local semantic codebase search via MCP — indexes projects into pgvector, exposes search to Claude",
   "license": "MIT",
   "main": "dist/app.js",
   "bin": {
     "rag-index": "dist/app.js",
-    "rag-mcp":   "dist/app.js",
+    "rag-mcp": "dist/app.js",
     "rag-setup": "dist/app.js"
   },
   "files": [
@@ -15,15 +15,15 @@
     "README.md"
   ],
   "scripts": {
-    "build":           "tsc",
-    "postbuild":       "node -e \"const fs=require('fs');const f='dist/app.js';fs.writeFileSync(f,'#!/usr/bin/env node\\n'+fs.readFileSync(f,'utf8'));fs.chmodSync(f,0o755);\"",
-    "prepublishOnly":  "npm run build && npm run typecheck",
-    "start:mcp":       "ts-node app.ts mcp",
+    "build": "tsc",
+    "postbuild": "node -e \"const fs=require('fs');const f='dist/app.js';fs.writeFileSync(f,'#!/usr/bin/env node\\n'+fs.readFileSync(f,'utf8'));fs.chmodSync(f,0o755);\"",
+    "prepublishOnly": "npm run build && npm run typecheck",
+    "start:mcp": "ts-node app.ts mcp",
     "index:workspace": "ts-node app.ts index",
-    "index:reindex":   "ts-node app.ts index --reindex",
-    "typecheck":       "tsc --noEmit",
-    "test":            "vitest run",
-    "test:watch":      "vitest"
+    "index:reindex": "ts-node app.ts index --reindex",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.4.1",
@@ -34,6 +34,7 @@
     "ignore": "^7.0.5",
     "ollama": "^0.5.0",
     "pg": "^8.13.0",
+    "pino": "^10.3.1",
     "reflect-metadata": "^0.2.2",
     "ts-morph": "^28.0.0",
     "typeorm": "^0.3.20",