codesearch-mcp 0.0.16-alpha → 0.0.17-alpha.1

package/dist/src/services/SearcherService.js

@@ -58,12 +58,13 @@ class SearcherService {
         this.logger = logger;
     }
     async prepareQuery(raw) {
+        const t0 = Date.now();
         if (this.config.search.autoTranslate && this.isNonEnglish(raw) && this.embedder.translate) {
             const query = await this.embedder.translate(raw, this.config.search.translateModel);
-            this.logger.debug('SearcherService: prepareQuery', { translated: true, raw: raw.slice(0, 120), query: query.slice(0, 120) });
+            this.logger.debug('SearcherService: prepareQuery', { translated: true, raw: raw.slice(0, 120), query: query.slice(0, 120), ms: Date.now() - t0 });
             return { query, translated: true };
         }
-        this.logger.debug('SearcherService: prepareQuery', { translated: false, query: raw.slice(0, 120) });
+        this.logger.debug('SearcherService: prepareQuery', { translated: false, query: raw.slice(0, 120), ms: Date.now() - t0 });
         return { query: raw, translated: false };
     }
     async listProjects() {
@@ -77,32 +78,51 @@ class SearcherService {
         });
     }
     async searchChunks(query, limit, project, threshold) {
+        const t0 = Date.now();
         const effectiveThreshold = threshold ?? this.config.search.similarityThreshold;
+        const fetchLimit = this.embedder.rerank
+            ? Math.min(limit * this.config.search.rerankerOverfetch, 200)
+            : limit;
         this.logger.debug('SearcherService: searchChunks', {
-            query: query.slice(0, 120), limit, project, threshold: effectiveThreshold,
+            query: query.slice(0, 120), limit, fetchLimit, project, threshold: effectiveThreshold,
         });
         const embedding = await this.embedder.embed(query);
-        const params = [`[${embedding}]`, effectiveThreshold, limit];
+        const params = [`[${embedding}]`, effectiveThreshold, fetchLimit];
         let projectFilter = '';
         if (project) {
             params.push(project);
             projectFilter = `AND "serviceName" = $${params.length}`;
         }
-        const results = await this.db.query(`SELECT "serviceName", "filePath", "startLine", content,
+        const candidates = await 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);
-        this.logger.debug('SearcherService: searchChunks results', {
-            count: results.length,
-            scores: results.map(r => r.score),
-            files: results.map(r => r.filePath),
+        this.logger.debug('SearcherService: searchChunks candidates', {
+            count: candidates.length,
+            scores: candidates.map(r => r.score),
+            files: candidates.map(r => r.filePath),
+            ms: Date.now() - t0,
         });
-        return results;
+        if (!this.embedder.rerank || candidates.length === 0)
+            return candidates;
+        try {
+            const indices = await this.embedder.rerank(query, candidates.map(r => r.content), limit);
+            this.logger.debug('SearcherService: searchChunks rerank done', { indices, ms: Date.now() - t0 });
+            return indices.filter(i => i >= 0 && i < candidates.length).map(i => candidates[i]);
+        }
+        catch (err) {
+            this.logger.warn('SearcherService: rerank failed, falling back to vector order', {
+                reason: err.message,
+                ms: Date.now() - t0,
+            });
+            return candidates.slice(0, limit);
+        }
     }
     async fetchNeighbors(results) {
+        const t0 = Date.now();
         if (results.length === 0)
             return [];
         this.logger.debug('SearcherService: fetchNeighbors', { count: results.length });
@@ -128,13 +148,64 @@ class SearcherService {
             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,
         }));
-        this.logger.debug('SearcherService: fetchNeighbors results', {
+        this.logger.debug('SearcherService: fetchNeighbors result', {
             withPrev: neighbors.filter(n => n.prevChunk).length,
             withNext: neighbors.filter(n => n.nextChunk).length,
+            ms: Date.now() - t0,
         });
         return neighbors;
     }
+    async fetchGraphContext(results) {
+        const t0 = Date.now();
+        const seen = new Map();
+        for (const r of results) {
+            const key = `${r.serviceName}::${r.filePath}`;
+            if (!seen.has(key))
+                seen.set(key, { filePath: r.filePath, project: r.serviceName });
+        }
+        const pairs = [...seen.values()];
+        this.logger.debug('SearcherService: fetchGraphContext', { files: pairs.length });
+        if (pairs.length === 0)
+            return new Map();
+        const n = pairs.length;
+        const firstHalf = pairs.map((_, i) => `($${i * 2 + 1}::text, $${i * 2 + 2}::text)`).join(', ');
+        const secondHalf = pairs.map((_, i) => `($${n * 2 + i * 2 + 1}::text, $${n * 2 + i * 2 + 2}::text)`).join(', ');
+        const params = [
+            ...pairs.flatMap(p => [p.filePath, p.project]),
+            ...pairs.flatMap(p => [p.filePath, p.project]),
+        ];
+        const rows = await this.db.query(`SELECT r.fp AS "filePath", 'import' AS direction, d."toFile" AS related
+         FROM (VALUES ${firstHalf}) AS r(fp, proj)
+         JOIN code_dependency d ON d."fromFile" = r.fp AND d.project = r.proj
+
+         UNION ALL
+
+         SELECT r.fp AS "filePath", 'usedby' AS direction, d."fromFile" AS related
+         FROM (VALUES ${secondHalf}) AS r(fp, proj)
+         JOIN code_dependency d ON d."toFile" = r.fp AND d.project = r.proj
+
+         LIMIT 2000`, params);
+        const ctx = new Map();
+        for (const { filePath } of pairs)
+            ctx.set(filePath, { imports: new Set(), usedBy: new Set() });
+        for (const row of rows) {
+            const g = ctx.get(row.filePath);
+            if (row.direction === 'import')
+                g.imports.add(row.related);
+            else
+                g.usedBy.add(row.related);
+        }
+        this.logger.debug('SearcherService: fetchGraphContext result', { files: pairs.length, rows: rows.length, ms: Date.now() - t0 });
+        const result = new Map();
+        for (const [fp, g] of ctx)
+            result.set(fp, {
+                imports: [...g.imports].slice(0, 50),
+                usedBy: [...g.usedBy].slice(0, 50),
+            });
+        return result;
+    }
     async getDependencies(filePath, project, symbol = null, transitive = false) {
+        const t0 = Date.now();
         this.logger.debug('SearcherService: getDependencies', { filePath, project, symbol, transitive });
         const params = [filePath, project];
         let symbolFilter = '';
@@ -148,7 +219,7 @@ class SearcherService {
        ${symbolFilter}
        ORDER BY "toFile"`, params);
         if (!transitive) {
-            this.logger.debug('SearcherService: getDependencies result', { direct: direct.length });
+            this.logger.debug('SearcherService: getDependencies result', { direct: direct.length, ms: Date.now() - t0 });
             return direct;
         }
         const indirect = await this.db.query(`WITH RECURSIVE deps AS (
@@ -173,10 +244,11 @@ class SearcherService {
        WHERE depth > 1
        GROUP BY "toFile"
        ORDER BY MIN(depth), "toFile"`, [filePath, project]);
-        this.logger.debug('SearcherService: getDependencies result', { direct: direct.length, indirect: indirect.length });
+        this.logger.debug('SearcherService: getDependencies result', { direct: direct.length, indirect: indirect.length, ms: Date.now() - t0 });
         return [...direct, ...indirect];
     }
     async getDependents(filePath, project, symbol = null, transitive = false) {
+        const t0 = Date.now();
         this.logger.debug('SearcherService: getDependents', { filePath, project, symbol, transitive });
         const params = [filePath, project];
         let symbolFilter = '';
@@ -190,7 +262,7 @@ class SearcherService {
        ${symbolFilter}
        ORDER BY "fromFile"`, params);
         if (!transitive) {
-            this.logger.debug('SearcherService: getDependents result', { direct: direct.length });
+            this.logger.debug('SearcherService: getDependents result', { direct: direct.length, ms: Date.now() - t0 });
             return direct;
         }
         const indirect = await this.db.query(`WITH RECURSIVE rdeps AS (
@@ -215,10 +287,29 @@ class SearcherService {
        WHERE depth > 1
        GROUP BY "fromFile"
        ORDER BY MIN(depth), "fromFile"`, [filePath, project]);
-        this.logger.debug('SearcherService: getDependents result', { direct: direct.length, indirect: indirect.length });
+        this.logger.debug('SearcherService: getDependents result', { direct: direct.length, indirect: indirect.length, ms: Date.now() - t0 });
         return [...direct, ...indirect];
     }
+    async getCallers(symbol, project, calleeFile = null) {
+        const t0 = Date.now();
+        this.logger.debug('SearcherService: getCallers', { symbol, project, calleeFile });
+        const params = [symbol, project];
+        let fileFilter = '';
+        if (calleeFile) {
+            params.push(calleeFile);
+            fileFilter = `AND "calleeFile" = $${params.length}`;
+        }
+        const rows = await this.db.query(`SELECT "fromFile", "fromSymbol", "calleeName", "calleeFile", line
+       FROM code_call
+       WHERE "calleeName" = $1 AND project = $2
+       ${fileFilter}
+       ORDER BY "fromFile", line
+       LIMIT 200`, params);
+        this.logger.debug('SearcherService: getCallers result', { count: rows.length, ms: Date.now() - t0 });
+        return rows;
+    }
     grepSymbol(symbol, project, excludeFile) {
+        const t0 = Date.now();
         this.logger.debug('SearcherService: grepSymbol', { symbol, project, excludeFile });
         const projectDir = path.join(this.config.workspaceRoot, project);
         const result = (0, child_process_1.spawnSync)('grep', [
@@ -245,7 +336,7 @@ class SearcherService {
             return [{ filePath: path.relative(this.config.workspaceRoot, absFile), line: parseInt(lineNum, 10) }];
         });
         const truncated = all.length > GREP_MAX_RESULTS;
-        this.logger.debug('SearcherService: grepSymbol result', { matches: Math.min(all.length, GREP_MAX_RESULTS), truncated });
+        this.logger.debug('SearcherService: grepSymbol result', { matches: Math.min(all.length, GREP_MAX_RESULTS), truncated, ms: Date.now() - t0 });
         return { matches: all.slice(0, GREP_MAX_RESULTS), truncated };
     }
     // Sync wrapper: validates name (throws synchronously), then returns Promise.
@@ -258,6 +349,7 @@ class SearcherService {
         return this.findSymbolFromIndex(name, project, kind);
     }
     async findSymbolFromIndex(name, project, kind) {
+        const t0 = Date.now();
         this.logger.debug('SearcherService: findSymbol', { name, project, kind, source: 'index' });
         try {
             const params = [name];
@@ -285,15 +377,16 @@ class SearcherService {
                 kind: row.kind,
                 signature: row.signature ?? row.name,
             }));
-            this.logger.debug('SearcherService: findSymbol result', { source: 'index', hits: hits.length, truncated });
+            this.logger.debug('SearcherService: findSymbol result', { source: 'index', hits: hits.length, truncated, ms: Date.now() - t0 });
             return { hits, truncated };
         }
         catch {
-            this.logger.warn('SearcherService: symbol index unavailable, falling back to grep', { name, project });
+            this.logger.warn('SearcherService: symbol index unavailable, falling back to grep', { name, project, ms: Date.now() - t0 });
             return this.grepFindSymbol(name, project, kind);
         }
     }
     grepFindSymbol(name, project, kind) {
+        const t0 = Date.now();
         this.logger.debug('SearcherService: findSymbol', { name, project, kind, source: 'grep' });
         const searchDir = project
             ? path.join(this.config.workspaceRoot, project)
@@ -335,10 +428,11 @@ class SearcherService {
                 signature: matchedLine.trim(),
             });
         }
-        this.logger.debug('SearcherService: findSymbol result', { source: 'grep', hits: hits.length, truncated: hits.length >= FIND_SYMBOL_LIMIT });
+        this.logger.debug('SearcherService: findSymbol result', { source: 'grep', hits: hits.length, truncated: hits.length >= FIND_SYMBOL_LIMIT, ms: Date.now() - t0 });
         return { hits, truncated: hits.length >= FIND_SYMBOL_LIMIT };
     }
     listFiles(relativePath, project, depth, pattern) {
+        const t0 = Date.now();
         this.logger.debug('SearcherService: listFiles', { relativePath, project, depth, pattern });
         const projectRoot = path.join(this.config.workspaceRoot, project);
         const resolvedTarget = path.resolve(projectRoot, relativePath);
@@ -355,13 +449,14 @@ class SearcherService {
         const clampedDepth = Math.min(5, Math.max(1, depth));
         const lines = [];
         this.walkDir(resolvedTarget, 0, clampedDepth - 1, pattern, lines);
-        this.logger.debug('SearcherService: listFiles result', { entries: lines.length });
+        this.logger.debug('SearcherService: listFiles result', { entries: lines.length, ms: Date.now() - t0 });
         if (lines.length === 0) {
             return { tree: pattern ? `No files matching "${pattern}" found.` : '(empty directory)' };
         }
         return { tree: lines.join('\n') };
     }
     async readFileAbsolute(absPath, maxLines) {
+        const t0 = Date.now();
         this.logger.debug('SearcherService: readFileAbsolute', { absPath, maxLines });
         const resolvedRoot = path.resolve(this.config.workspaceRoot);
         const resolved = path.resolve(absPath);
@@ -395,10 +490,11 @@ class SearcherService {
             throw err;
         }
         const relPath = path.relative(resolvedRoot, resolved);
-        this.logger.debug('SearcherService: readFileAbsolute result', { linesRead: lines.length, hasMore });
+        this.logger.debug('SearcherService: readFileAbsolute result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
         return { ok: true, filePath: relPath, startLine: 1, endLine: lines.length, lines, hasMore };
     }
     async readFileRange(filePath, startLine, endLine) {
+        const t0 = Date.now();
         this.logger.debug('SearcherService: readFileRange', { filePath, startLine, endLine });
         const resolvedRoot = path.resolve(this.config.workspaceRoot);
         const absPath = path.resolve(resolvedRoot, filePath);
@@ -429,7 +525,7 @@ class SearcherService {
                 break;
             }
         }
-        this.logger.debug('SearcherService: readFileRange result', { linesRead: lines.length, hasMore });
+        this.logger.debug('SearcherService: readFileRange result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
         return { ok: true, filePath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
     }
     isNonEnglish(text) {

package/dist/src/setup.js

@@ -40,11 +40,14 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
 const constants_1 = require("./constants");
-const CONFIG_DIR = path.join(os.homedir(), '.config', 'codesearch-mcp');
-const DEFAULT_LOG_DIR = path.join(CONFIG_DIR, 'logs');
-const CONFIG_FILE = path.join(CONFIG_DIR, '.env');
-const DOCKER_COMPOSE_SRC = path.join(__dirname, '..', '..', 'docker', 'docker-compose.yml');
-const DOCKER_COMPOSE_DST = path.join(CONFIG_DIR, 'docker-compose.yml');
+const config_store_1 = require("./config-store");
+const config_1 = require("./config");
+const DEFAULT_LOG_DIR = path.join(config_store_1.CONFIG_DIR, 'logs');
+const _projectRoot = fs.existsSync(path.join(__dirname, '..', 'package.json'))
+    ? path.join(__dirname, '..')
+    : path.join(__dirname, '..', '..');
+const DOCKER_COMPOSE_SRC = path.join(_projectRoot, 'docker', 'docker-compose.yml');
+const DOCKER_COMPOSE_DST = path.join(config_store_1.CONFIG_DIR, 'docker-compose.yml');
 function ask(rl, question) {
     return new Promise(resolve => rl.question(question, resolve));
 }
@@ -57,14 +60,6 @@ function expandHome(p) {
         return path.join(os.homedir(), p.slice(2));
     return p;
 }
-function writeEnv(vars) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    const content = Object.entries(vars)
-        .map(([k, v]) => `${k}=${v}`)
-        .join('\n') + '\n';
-    fs.writeFileSync(CONFIG_FILE, content, { mode: 0o600 });
-    console.log(`\nConfig saved to ${CONFIG_FILE}`);
-}
 async function waitForDb(host, port, user, pass, db, maxWaitSec = 60, logger, steps) {
     const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
     const deadline = Date.now() + maxWaitSec * 1000;
@@ -129,7 +124,7 @@ async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
         return false;
     }
 }
-async function setupLocalDocker(ollamaHost, dbPort, dbUser, dbPass, logger, steps) {
+async function startDockerContainers(ollamaHost, dbPort, dbUser, dbPass, logger, steps) {
     console.log('\nWriting docker-compose.yml to', DOCKER_COMPOSE_DST);
     const yamlQuote = (s) => `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
     let composeContent = fs.readFileSync(DOCKER_COMPOSE_SRC, 'utf-8');
@@ -137,57 +132,29 @@ async function setupLocalDocker(ollamaHost, dbPort, dbUser, dbPass, logger, step
         .replace('POSTGRES_USER: dev', `POSTGRES_USER: ${yamlQuote(dbUser)}`)
         .replace('POSTGRES_PASSWORD: dev', `POSTGRES_PASSWORD: ${yamlQuote(dbPass)}`)
         .replace('"5433:5432"', `"${dbPort}:5432"`);
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.mkdirSync(config_store_1.CONFIG_DIR, { recursive: true });
     fs.writeFileSync(DOCKER_COMPOSE_DST, composeContent, 'utf-8');
     console.log('\nStarting Docker containers...');
     const upResult = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'up', '-d'], { stdio: 'inherit' });
     if (upResult.status !== 0) {
         const reason = 'Failed to start Docker containers. Make sure Docker is running.';
         console.error(reason);
-        logger?.error('setupLocalDocker: docker startup failed', { reason, steps });
+        logger?.error('startDockerContainers: docker startup failed', { reason, steps });
         process.exit(1);
     }
     await waitForDb('localhost', parseInt(dbPort), dbUser, dbPass, 'postgres', 60, logger, steps);
     await waitForOllama(ollamaHost, 60, logger, steps);
-    // 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
-    // users install via npm -g or move the compose file around.
     const ollamaId = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'ps', '-q', 'ollama'], { encoding: 'utf-8' })
         .stdout?.trim();
     if (!ollamaId) {
         const reason = 'Could not resolve ollama container ID from compose. Pull the model manually:';
         console.error(reason);
         console.error(`  docker exec <ollama-container> ollama pull ${constants_1.DEFAULT_EMBED_MODEL}`);
-        logger?.error('setupLocalDocker: ollama container not found', { reason, steps });
+        logger?.error('startDockerContainers: ollama container not found', { reason, steps });
         process.exit(1);
     }
     console.log(`Pulling ${constants_1.DEFAULT_EMBED_MODEL} model (this may take a while)...`);
     (0, child_process_1.spawnSync)('docker', ['exec', ollamaId, 'ollama', 'pull', constants_1.DEFAULT_EMBED_MODEL], { stdio: 'inherit' });
-    return { DB_HOST: 'localhost', DB_PORT: dbPort, DB_USER: dbUser, DB_PASS: dbPass };
-}
-async function setupRemoteDb(rl, logger, steps, logStep) {
-    const lp = async (label, def) => {
-        const answer = await prompt(rl, label, def);
-        logStep?.(label, answer);
-        return answer;
-    };
-    let vars = {};
-    while (true) {
-        vars.DB_HOST = await lp('DB host', 'localhost');
-        vars.DB_PORT = await lp('DB port', '5432');
-        vars.DB_USER = await lp('DB user', 'postgres');
-        vars.DB_PASS = await lp('DB password', '');
-        console.log('\nTesting connection...');
-        const ok = await checkRemoteDb(vars.DB_HOST, vars.DB_PORT, vars.DB_USER, vars.DB_PASS, 'postgres', logger, steps);
-        if (ok) {
-            console.log('Connection successful.');
-            break;
-        }
-        const retry = await ask(rl, 'Retry? (y/n): ');
-        if (retry.trim().toLowerCase() !== 'y')
-            break;
-    }
-    return vars;
 }
 async function runSetup(logger) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -210,14 +177,12 @@ async function runSetup(logger) {
     };
     console.log('=== codesearch-mcp setup ===');
     console.log('Press Enter to keep the default value shown in parentheses.\n');
-    const dbChoice = await loggedAsk('Infrastructure:\n  1. Local Docker (auto-start PostgreSQL + Ollama)\n  2. Remote (Supabase, Railway, self-hosted DB + local Ollama)\n\nEnter choice (1): ');
-    const useDocker = (dbChoice.trim() || '1') === '1';
     const workspaceExample = (() => {
         const candidates = ['Projects', 'projects', 'workspace', 'code', 'Code', 'dev', 'Development'];
         const found = candidates.find(d => fs.existsSync(path.join(os.homedir(), d)));
         return path.join(os.homedir(), found ?? 'projects');
     })();
-    console.log(`\nWorkspace root — full path to the directory that contains all your projects`);
+    console.log(`Workspace root — full path to the directory that contains all your projects`);
     console.log(`  (e.g. ${workspaceExample})`);
     let workspaceInput;
     do {
@@ -227,12 +192,39 @@ async function runSetup(logger) {
     } while (!workspaceInput.trim());
     const workspaceRoot = expandHome(workspaceInput.trim());
     const ollamaHost = await loggedPrompt('Ollama API URL', 'http://localhost:11434');
-    const dbVars = useDocker
-        ? await setupLocalDocker(ollamaHost, await loggedPrompt('DB port', '5433'), await loggedPrompt('DB user', 'dev'), await loggedPrompt('DB password', 'dev'), logger, steps)
-        : await setupRemoteDb(rl, logger, steps, logStep);
+    console.log('\n--- Database ---');
+    const dbHost = await loggedPrompt('DB host', 'localhost');
+    const dbPort = await loggedPrompt('DB port', '5433');
+    const dbUser = await loggedPrompt('DB user', 'dev');
+    const dbPass = await loggedPrompt('DB password', 'dev');
+    process.stdout.write('\nTesting connection...');
+    const alreadyConnected = await checkRemoteDb(dbHost, dbPort, dbUser, dbPass, 'postgres', logger, steps);
+    if (alreadyConnected)
+        console.log('  Database is already reachable.');
+    const dockerDefault = alreadyConnected ? 'n' : 'y';
+    const startDockerRaw = await loggedAsk(`Start Docker containers automatically? (y/n) (${dockerDefault}): `);
+    const startDocker = (startDockerRaw.trim().toLowerCase() || dockerDefault) === 'y';
+    if (startDocker) {
+        await startDockerContainers(ollamaHost, dbPort, dbUser, dbPass, logger, steps);
+    }
+    else if (!alreadyConnected) {
+        while (true) {
+            console.log('\nTesting connection...');
+            const ok = await checkRemoteDb(dbHost, dbPort, dbUser, dbPass, 'postgres', logger, steps);
+            if (ok) {
+                console.log('Connection successful.');
+                break;
+            }
+            const retry = await ask(rl, 'Retry? (y/n): ');
+            if (retry.trim().toLowerCase() !== 'y')
+                break;
+        }
+    }
+    const dbVars = { host: dbHost, port: parseInt(dbPort, 10), user: dbUser, password: dbPass };
     console.log('\n--- Logging ---');
     console.log('  error  — failures only (recommended)');
     console.log('  warn   — + recoverable issues');
+    console.log('  info   — + general progress messages');
     console.log('  debug  — full diagnostic output (verbose)');
     const validLevels = ['error', 'warn', 'info', 'debug'];
     let logLevel;
@@ -243,22 +235,25 @@ async function runSetup(logger) {
     } while (!validLevels.includes(logLevel));
     const logDirInput = await loggedAsk(`Log dir (leave blank for default: ${DEFAULT_LOG_DIR}, or "false" to disable): `);
     const logDir = logDirInput.trim();
-    const envVars = {
-        ...dbVars,
-        WORKSPACE_ROOT: workspaceRoot,
-        OLLAMA_HOST: ollamaHost,
-        LOG_LEVEL: logLevel,
+    const cfg = {
+        db: {
+            host: dbVars.host,
+            port: dbVars.port,
+            user: dbVars.user,
+            password: dbVars.password,
+        },
+        ollama: { host: ollamaHost },
+        logging: { level: logLevel },
+        workspaceRoot,
     };
     if (logDir)
-        envVars['LOG_DIR'] = logDir;
-    writeEnv(envVars);
+        cfg.logging.dir = logDir;
+    (0, config_store_1.writeConfigJson)(cfg);
+    console.log(`\nConfig saved to ${config_store_1.CONFIG_FILE}`);
     rl.close();
     console.log('\nInitializing database schema...');
-    const dotenv = await Promise.resolve().then(() => __importStar(require('dotenv')));
-    dotenv.config({ path: CONFIG_FILE, override: true });
-    const { config } = await Promise.resolve().then(() => __importStar(require('./config')));
     const { DatabaseService } = await Promise.resolve().then(() => __importStar(require('./services/DatabaseService')));
-    const dbService = new DatabaseService(config);
+    const dbService = new DatabaseService(new config_1.Config());
     let initError = null;
     try {
         await dbService.initDbWithSchema();

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "codesearch-mcp",
-  "version": "0.0.16-alpha",
+  "version": "0.0.17-alpha.1",
   "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-setup": "dist/app.js"
+    "rag-setup": "dist/app.js",
+    "rag-config": "dist/app.js"
   },
   "files": [
     "dist/",
@@ -33,7 +34,6 @@
     "@langchain/textsplitters": "^1.0.1",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "cli-progress": "^3.12.0",
-    "dotenv": "^17.4.2",
     "drizzle-orm": "^0.45.2",
     "ignore": "^7.0.5",
     "ollama": "^0.5.0",