codesearch-mcp 0.0.12-alpha → 0.0.14-alpha

package/README.md

@@ -34,7 +34,7 @@ rag-setup
 Walks you through:
 - **Local Docker** — copies `docker-compose.yml`, starts PostgreSQL + Ollama, pulls `bge-m3` automatically
 - **Remote DB** — enter connection details for Supabase, Railway, or self-hosted; connection is verified before saving
-- **Logging** — choose log level and file path (defaults: `error` level, `~/.config/codesearch-mcp/rag.log`)
+- **Logging** — choose log level and directory (defaults: `error` level, `~/.config/codesearch-mcp/logs/`)
 
 Config is saved to `~/.config/codesearch-mcp/.env`.
 
@@ -102,18 +102,18 @@ src/generated/
 
 ## Logging
 
-Logs are written to `~/.config/codesearch-mcp/rag.log` by default. Only errors are logged unless configured otherwise.
+Logs are written to `~/.config/codesearch-mcp/logs/` by default (separate subdirectories for indexer and MCP). Only errors are logged unless configured otherwise.
 
 ```bash
 # Read logs
-tail -f ~/.config/codesearch-mcp/rag.log
-npx pino-pretty < ~/.config/codesearch-mcp/rag.log
+tail -f ~/.config/codesearch-mcp/logs/indexer/current.log
+npx pino-pretty < ~/.config/codesearch-mcp/logs/indexer/current.log
 
 # Detailed indexing diagnostics (timing per file: deps / embed / db)
 LOG_LEVEL=debug rag-index /path/to/workspace
 
 # Disable file logging
-LOG_FILE=false rag-index /path/to/workspace
+LOG_DIR=false rag-index /path/to/workspace
 ```
 
 ## Environment variables
@@ -134,7 +134,7 @@ All set by `rag-setup`. Override any of them in `~/.config/codesearch-mcp/.env`.
 | `AUTO_TRANSLATE` | `false` | Translate non-English queries to English before embedding |
 | `TRANSLATE_MODEL` | `llama3.2` | Ollama model for translation (requires `ollama pull llama3.2`) |
 | `LOG_LEVEL` | `error` | Log level written to file: `error` \| `warn` \| `info` \| `debug` |
-| `LOG_FILE` | `~/.config/codesearch-mcp/rag.log` | Log file path, or `false` to disable |
+| `LOG_DIR` | `~/.config/codesearch-mcp/logs` | Base log directory, or `false` to disable |
 
 ## License
 

package/dist/app.js

@@ -53,7 +53,8 @@ async function main() {
         (0, help_1.printHelp)(argv1 !== 'app.js' ? argv1 : mode);
         process.exit(0);
     }
-    const container = (0, container_1.createContainer)();
+    const loggerName = mode === 'index' || mode === 'backfill' ? 'indexer' : mode === 'mcp' ? 'mcp' : mode === 'setup' ? 'setup' : undefined;
+    const container = (0, container_1.createContainer)(loggerName);
     if (!container.config.workspaceRoot && mode !== 'setup') {
         const hint = argv1 === 'rag-mcp'
             ? 'Set WORKSPACE_ROOT in ~/.config/codesearch-mcp/.env or run `rag-setup`.'
@@ -64,7 +65,7 @@ async function main() {
     const commands = {
         index: new IndexCommand_1.IndexCommand(container, argv1),
         mcp: new McpCommand_1.McpCommand(container),
-        setup: new SetupCommand_1.SetupCommand(),
+        setup: new SetupCommand_1.SetupCommand(container),
         backfill: new BackfillCommand_1.BackfillCommand(container),
     };
     const cmd = commands[mode];

package/dist/src/commands/McpCommand.js

@@ -7,9 +7,22 @@ class McpCommand {
         this.container = container;
     }
     async execute() {
-        const { db, mcp } = this.container;
-        await db.initDb();
-        await mcp.start();
+        const { db, mcp, logger } = this.container;
+        let startupError;
+        try {
+            await db.initDb();
+        }
+        catch (err) {
+            startupError = err;
+            logger.error('McpCommand: database connection failed', { reason: err.message });
+        }
+        try {
+            await mcp.start(startupError);
+        }
+        catch (err) {
+            logger.error('McpCommand: MCP server failed to start', { reason: err.message });
+            return;
+        }
         // server.connect() resolves immediately after setup; keep the process alive
         // until the MCP client disconnects (stdin closes)
         await new Promise(resolve => {

package/dist/src/commands/SetupCommand.d.ts

@@ -1,4 +1,7 @@
+import type { Container } from '../container';
 import type { ICommand } from './ICommand';
 export declare class SetupCommand implements ICommand {
+    private container;
+    constructor(container: Container);
     execute(): Promise<void>;
 }

package/dist/src/commands/SetupCommand.js

@@ -3,8 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetupCommand = void 0;
 const setup_1 = require("../setup");
 class SetupCommand {
+    container;
+    constructor(container) {
+        this.container = container;
+    }
     async execute() {
-        await (0, setup_1.runSetup)();
+        await (0, setup_1.runSetup)(this.container.logger);
     }
 }
 exports.SetupCommand = SetupCommand;

package/dist/src/container.d.ts

@@ -12,4 +12,4 @@ export interface Container {
     mcp: McpServer;
     logger: LoggerService;
 }
-export declare function createContainer(): Container;
+export declare function createContainer(loggerName?: string): Container;

package/dist/src/container.js

@@ -9,8 +9,8 @@ const IndexerService_1 = require("./services/IndexerService");
 const SearcherService_1 = require("./services/SearcherService");
 const McpServer_1 = require("./services/McpServer");
 const LoggerService_1 = require("./services/LoggerService");
-function createContainer() {
-    const logger = LoggerService_1.LoggerService.fromEnv();
+function createContainer(loggerName) {
+    const logger = LoggerService_1.LoggerService.fromEnv(loggerName);
     const db = new DatabaseService_1.DatabaseService(config_1.config);
     const embedder = new OllamaEmbedder_1.OllamaEmbedder(config_1.config);
     const ast = new AstParserService_1.AstParserService(logger);

package/dist/src/interfaces/IAstParser.d.ts

@@ -10,7 +10,7 @@ export interface SymbolEntry {
     project: string;
     filePath: string;
     name: string;
-    kind: 'function' | 'class' | 'interface' | 'type' | 'variable';
+    kind: 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method';
     signature: string | null;
     line: number | null;
     col: number | null;

package/dist/src/project-selector.js

@@ -37,37 +37,49 @@ exports.selectProjects = selectProjects;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const prompts_1 = require("@inquirer/prompts");
-function loadLines(filePath) {
-    if (!fs.existsSync(filePath))
+async function loadLines(filePath) {
+    try {
+        const content = await fs.promises.readFile(filePath, 'utf-8');
+        return new Set(content.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#')));
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT')
+            throw err;
         return new Set();
-    return new Set(fs.readFileSync(filePath, 'utf-8')
-        .split('\n')
-        .map(l => l.trim())
-        .filter(l => l && !l.startsWith('#')));
+    }
 }
 // Write the set if non-empty, otherwise delete the file so state is deterministic.
 // Previously .ragskip could be left stale (last entry removed but file not rewritten);
 // treating both files the same way avoids that drift.
-function saveLines(filePath, names) {
+async function saveLines(filePath, names) {
     if (names.size > 0) {
-        fs.writeFileSync(filePath, [...names].sort().join('\n') + '\n');
+        await fs.promises.writeFile(filePath, [...names].sort().join('\n') + '\n');
     }
-    else if (fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
+    else {
+        try {
+            await fs.promises.unlink(filePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
     }
 }
-function loadConfig(workspaceDir) {
-    return {
-        included: loadLines(path.join(workspaceDir, '.ragprojects')),
-        skipped: loadLines(path.join(workspaceDir, '.ragskip')),
-    };
+async function loadConfig(workspaceDir) {
+    const [included, skipped] = await Promise.all([
+        loadLines(path.join(workspaceDir, '.ragprojects')),
+        loadLines(path.join(workspaceDir, '.ragskip')),
+    ]);
+    return { included, skipped };
 }
-function saveConfig(workspaceDir, config) {
-    saveLines(path.join(workspaceDir, '.ragprojects'), config.included);
-    saveLines(path.join(workspaceDir, '.ragskip'), config.skipped);
+async function saveConfig(workspaceDir, config) {
+    await Promise.all([
+        saveLines(path.join(workspaceDir, '.ragprojects'), config.included),
+        saveLines(path.join(workspaceDir, '.ragskip'), config.skipped),
+    ]);
 }
 async function selectProjects(allProjects, workspaceDir, forceSelect) {
-    const config = loadConfig(workspaceDir);
+    const config = await loadConfig(workspaceDir);
     const newProjects = allProjects.filter(p => !config.included.has(p.name) && !config.skipped.has(p.name));
     // Nothing to ask — return previously saved selection silently
     if (newProjects.length === 0 && !forceSelect) {
@@ -121,7 +133,7 @@ async function selectProjects(allProjects, workspaceDir, forceSelect) {
         for (const name of toSkip)
             config.skipped.add(name);
     }
-    saveConfig(workspaceDir, config);
+    await saveConfig(workspaceDir, config);
     const selected = allProjects.filter(p => config.included.has(p.name));
     console.log(`\nSelected: ${selected.map(p => p.name).join(', ') || '(none)'}`);
     return selected;

package/dist/src/services/AstParserService.js

@@ -43,6 +43,7 @@ const FALLBACK_OPTS = {
     skipFileDependencyResolution: false,
     compilerOptions: { allowJs: true, noEmit: true },
 };
+const MORPH_CACHE_MAX = 10;
 class AstParserService {
     logger;
     morphProjects = new Map();
@@ -75,38 +76,49 @@ class AstParserService {
         const { edges } = await this.analyzeFile(filePath, serviceName, projectRoot);
         return edges;
     }
-    // ── private: MorphProject cache ────────────────────────────────────────────
+    // ── private: MorphProject cache (LRU, max MORPH_CACHE_MAX entries) ──────────
     getMorphProject(projectRoot) {
-        if (!this.morphProjects.has(projectRoot)) {
-            const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
-            const hasTsconfig = fs.existsSync(tsconfigPath);
-            this.logger.debug('AstParser: tsconfig lookup', { projectRoot, found: hasTsconfig });
-            let project;
-            try {
-                const opts = hasTsconfig
-                    ? { tsConfigFilePath: tsconfigPath, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false }
-                    : FALLBACK_OPTS;
-                project = new ts_morph_1.Project(opts);
-                if (hasTsconfig) {
-                    const co = project.getCompilerOptions();
-                    const pathsMap = co.paths ?? {};
-                    const pathCount = Object.keys(pathsMap).length;
-                    this.logger.debug('AstParser: tsconfig loaded', { pathCount });
-                    if (pathCount > 0) {
-                        this.logger.debug('AstParser: path aliases', { aliases: Object.keys(pathsMap) });
-                    }
+        if (this.morphProjects.has(projectRoot)) {
+            // Move to end = most recently used
+            const cached = this.morphProjects.get(projectRoot);
+            this.morphProjects.delete(projectRoot);
+            this.morphProjects.set(projectRoot, cached);
+            return cached;
+        }
+        if (this.morphProjects.size >= MORPH_CACHE_MAX) {
+            // Evict least recently used (first entry in insertion-order Map)
+            const lruKey = this.morphProjects.keys().next().value;
+            this.morphProjects.delete(lruKey);
+            this.logger.debug('AstParser: evicted LRU project', { lruKey });
+        }
+        const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+        const hasTsconfig = fs.existsSync(tsconfigPath);
+        this.logger.debug('AstParser: tsconfig lookup', { projectRoot, found: hasTsconfig });
+        let project;
+        try {
+            const opts = hasTsconfig
+                ? { tsConfigFilePath: tsconfigPath, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false }
+                : FALLBACK_OPTS;
+            project = new ts_morph_1.Project(opts);
+            if (hasTsconfig) {
+                const co = project.getCompilerOptions();
+                const pathsMap = co.paths ?? {};
+                const pathCount = Object.keys(pathsMap).length;
+                this.logger.debug('AstParser: tsconfig loaded', { pathCount });
+                if (pathCount > 0) {
+                    this.logger.debug('AstParser: path aliases', { aliases: Object.keys(pathsMap) });
                 }
             }
-            catch (err) {
-                this.logger.warn('AstParser: tsconfig load failed, using fallback', {
-                    tsconfigPath,
-                    reason: err.message,
-                });
-                project = new ts_morph_1.Project(FALLBACK_OPTS);
-            }
-            this.morphProjects.set(projectRoot, project);
         }
-        return this.morphProjects.get(projectRoot);
+        catch (err) {
+            this.logger.warn('AstParser: tsconfig load failed, using fallback', {
+                tsconfigPath,
+                reason: err.message,
+            });
+            project = new ts_morph_1.Project(FALLBACK_OPTS);
+        }
+        this.morphProjects.set(projectRoot, project);
+        return project;
     }
     // ── private: edge extraction (imports + re-exports) ────────────────────────
     extractEdges(sourceFile, filePath, serviceName) {
@@ -116,7 +128,8 @@ class AstParserService {
             const resolved = decl.getModuleSpecifierSourceFile();
             if (!resolved) {
                 const specifier = decl.getModuleSpecifierValue();
-                if (specifier.startsWith('.')) {
+                const isCodeImport = !/\.(json|css|scss|less|svg|png|jpg|gif|ico|woff2?|ttf|eot)(\?.*)?$/.test(specifier);
+                if (specifier.startsWith('.') && isCodeImport) {
                     this.logger.debug('AstParser: unresolved import', { specifier, file: filePath });
                 }
                 continue;

package/dist/src/services/DatabaseService.js

@@ -108,7 +108,8 @@ class DatabaseService {
             await client.connect();
             const { rows } = await client.query(`SELECT 1 FROM pg_database WHERE datname = $1`, [database]);
             if (rows.length === 0) {
-                await client.query(`CREATE DATABASE "${database}"`);
+                const safeName = database.replace(/"/g, '""');
+                await client.query(`CREATE DATABASE "${safeName}"`);
                 await client.end();
                 const extClient = new pg_1.Client({ host, port, user: username, password, database });
                 try {
@@ -126,7 +127,8 @@ class DatabaseService {
         }
         catch (err) {
             await client.end().catch(() => { });
-            throw new Error(`Failed to ensure database "${database}" exists: ${err.message}`);
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Failed to ensure database "${database}" exists: ${msg}`);
         }
     }
 }

package/dist/src/services/IndexerService.js

@@ -80,7 +80,7 @@ class IndexerService {
             }
             try {
                 const { symbols: rawSymbols } = await this.ast.analyzeFile(absPath, serviceName, projectRoot);
-                const symbols = rawSymbols.map(s => ({ ...s, filePath }));
+                const symbols = [...new Map(rawSymbols.map(s => ({ ...s, filePath })).map(s => [`${s.name}:${s.kind}`, s])).values()];
                 await this.db.transaction(async (manager) => {
                     await manager.delete(db_1.CodeSymbol, { project: serviceName, filePath });
                     if (symbols.length > 0) {
@@ -223,7 +223,7 @@ class IndexerService {
                 toFile: path.relative(this.config.workspaceRoot, e.toFile),
             }));
             // normalize symbols: replace absolute filePath with workspace-relative
-            const symbols = rawSymbols.map(s => ({ ...s, filePath: relFilePath }));
+            const symbols = [...new Map(rawSymbols.map(s => ({ ...s, filePath: relFilePath })).map(s => [`${s.name}:${s.kind}`, s])).values()];
             const depsMs = Date.now() - t0;
             const code = fs.readFileSync(filePath, 'utf-8');
             const chunks = await this.getSplitter(filePath).createDocuments([code]);

package/dist/src/services/LoggerService.d.ts

@@ -4,7 +4,7 @@ export declare class LoggerService {
     private readonly logger;
     constructor(logger: pino.Logger);
     static silent(): LoggerService;
-    static fromEnv(): LoggerService;
+    static fromEnv(name?: string): LoggerService;
     debug(msg: string, data?: Record<string, unknown>): void;
     info(msg: string, data?: Record<string, unknown>): void;
     warn(msg: string, data?: Record<string, unknown>): void;

package/dist/src/services/LoggerService.js

@@ -41,7 +41,7 @@ const pino_1 = __importDefault(require("pino"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const fs = __importStar(require("fs"));
-const DEFAULT_LOG_FILE = path.join(os.homedir(), '.config', 'codesearch-mcp', 'rag.log');
+const DEFAULT_LOG_DIR = path.join(os.homedir(), '.config', 'codesearch-mcp', 'logs');
 class LoggerService {
     logger;
     constructor(logger) {
@@ -50,15 +50,35 @@ class LoggerService {
     static silent() {
         return new LoggerService((0, pino_1.default)({ level: 'silent' }));
     }
-    static fromEnv() {
+    static fromEnv(name) {
         const level = (process.env.LOG_LEVEL ?? 'error');
-        const logFileEnv = process.env.LOG_FILE;
-        const enabled = logFileEnv !== 'false' && logFileEnv !== '0';
-        const filePath = enabled ? (logFileEnv || DEFAULT_LOG_FILE) : null;
+        const logDirEnv = process.env.LOG_DIR;
+        const enabled = logDirEnv !== 'false' && logDirEnv !== '0';
+        let filePath = null;
+        if (enabled) {
+            const logDir = logDirEnv || DEFAULT_LOG_DIR;
+            filePath = name
+                ? path.join(logDir, name, `${name}.log`)
+                : path.join(logDir, 'rag.log');
+        }
         if (filePath)
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
         const transport = filePath
-            ? pino_1.default.transport({ targets: [{ target: 'pino/file', options: { destination: filePath }, level }] })
+            ? pino_1.default.transport({
+                targets: [{
+                        target: 'pino-roll',
+                        options: {
+                            file: filePath,
+                            frequency: 'daily',
+                            dateFormat: 'yyyy-MM-dd',
+                            mkdir: true,
+                            symlink: true,
+                            limit: { count: 30 },
+                            size: '50m',
+                        },
+                        level,
+                    }],
+            })
             : undefined;
         const logger = transport
             ? (0, pino_1.default)({ level }, transport)

package/dist/src/services/McpServer.d.ts

@@ -6,7 +6,7 @@ export declare class McpServer {
     private config;
     private logger;
     constructor(searcher: SearcherService, config: Config, logger?: LoggerService);
-    start(): Promise<void>;
+    start(startupError?: Error): Promise<void>;
     private formatChunk;
     private formatDependencies;
     private formatDependents;

package/dist/src/services/McpServer.js

@@ -58,36 +58,29 @@ You have access to a local semantic code search server. Use these tools to navig
 - **read_file_range** — read a specific line range from any indexed file. Use this to expand context around a search result.
 - **get_dependencies** — show what files a given file imports (direct or transitive). Use to understand what a file depends on.
 - **get_dependents** — show which files import a given file (reverse graph). Use before refactoring to find all callers.
-- **find_symbol** — find where a symbol (function, class, type, interface, variable) is defined by exact name. Faster than semantic search when you know the name.
+- **find_symbol** — find where a symbol (function, class, type, interface, variable, method) is defined by exact name. Faster than semantic search when you know the name.
 - **list_files** — browse the directory tree of a project path. Use to understand project structure before reading files.
 - **read_file** — read a complete file by absolute path with line numbers. Truncates at max_lines with a hint to continue.
 
 ## Recommended workflow
 
 1. Use \`list_projects\` to discover available projects before filtering by \`project\`.
-2. Use \`search_codebase\` to find relevant code by meaning.
-3. If a result looks **truncated or incomplete** (e.g. you see only the middle of a function), call \`read_file_range\` with the returned \`file_path\` and \`start_line\` set to the **Line** number shown in the result. Example: if the result shows **Line:** 150, pass \`start_line: 150\`.
-4. For exploratory searches where you expect results to span chunk boundaries, pass \`include_neighbors: true\` to automatically include the chunk before and after each match.
-5. Use \`find_symbol\` when you know the exact name of a function or class and want its definition location immediately — faster than semantic search.
+2. **Before searching**: if your query uses an ambiguous term (e.g. "subscription" could mean pub/sub or billing), pass a lower \`threshold\` (e.g. \`0.35\`) to \`search_codebase\` to filter out weak matches. Default threshold is permissive — tighten it when semantic drift is likely.
+3. Use \`search_codebase\` to find relevant code by meaning.
+4. If a result **starts mid-function or mid-class** (e.g. you see a closing brace or a method body without the declaration), re-run the same search with \`include_neighbors: true\` — it automatically fetches the chunk before and after each match. If you need a specific line range, use \`read_file_range\` instead.
+5. Use \`find_symbol\` when you know the exact name of a function, class, or method and want its definition location immediately — faster than semantic search. Use \`kind: "method"\` to find public class methods like \`canActivate\`, \`execute\`, \`handle\`.
 6. Use \`list_files\` to explore project structure (src/, components/, etc.) before diving into files.
 7. Use \`read_file\` to read a complete file when you have its absolute path from \`search_codebase\` results.
 
-## When to use read_file_range vs include_neighbors
+## Dependency graph
 
-- **include_neighbors: true** — good when you already know the context will be fragmented (e.g. searching for a class definition that's likely split across chunks).
-- **read_file_range** — better when you want to read a precise section, or when a result looks cut off and you want to expand just that one file.
+\`get_dependencies\` and \`get_dependents\` require \`file_path\` (as returned by \`search_codebase\`) and \`project\` (from \`list_projects\`). Pass \`transitive: true\` for the full dependency chain. depType values: \`import\` | \`import-default\` | \`import-namespace\` | \`reexport\` | \`reexport-namespace\`. \`fromSymbol\` — the top-level class or function in the importing file that uses this import (null if ambiguous or not tracked).
 
-## Handling Code Structure
-- **Class/Function limits**: Chunks often end abruptly. Always use \`read_file_range\` to find the closing brace or the beginning of a method if you suspect you're seeing only a fragment.
-- **Cross-file references**: If you see a method call like \`this.validator.validate(data)\`, use \`search_codebase\` to find the definition of that \`validator\` service.
+If \`get_dependents\` returns 0 results, add \`symbol\` (the exported name you care about) — this triggers a grep fallback that finds runtime usages in DI containers, string references, and dynamic lookups that the import graph misses.
 
 ## Relevance scores
 
-Lower score = better match (cosine distance). Results above the configured threshold are filtered out automatically.
-
-## Dependency graph
-
-\`get_dependencies\` and \`get_dependents\` require \`file_path\` (as returned by \`search_codebase\`) and \`project\` (from \`list_projects\`). Pass \`transitive: true\` for the full dependency chain. depType values: \`import\` | \`import-default\` | \`import-namespace\` | \`reexport\` | \`reexport-namespace\`. \`fromSymbol\` — the top-level class or function in the importing file that uses this import (null if ambiguous or not tracked).
+Lower score = better match (cosine distance). Results above the configured threshold are filtered out automatically. Pass \`threshold\` to \`search_codebase\` to override per-query (e.g. \`0.35\` for strict, \`0.55\` for broad).
 `.trim();
 class McpServer {
     searcher;
@@ -98,7 +91,7 @@ class McpServer {
         this.config = config;
         this.logger = logger;
     }
-    async start() {
+    async start(startupError) {
         const server = new index_js_1.Server({ name: 'local-rag', version: PKG_VERSION }, { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS });
         server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
             tools: [
@@ -112,6 +105,7 @@ class McpServer {
                             limit: { type: 'number', description: `Max results (default ${this.config.search.defaultLimit}, max ${this.config.search.maxLimit})` },
                             project: { type: 'string', description: 'Filter by project name (optional). Use list_projects to see available names.' },
                             include_neighbors: { type: 'boolean', description: 'Also include the chunk before and after each result from the same file (Small-to-Big retrieval). Useful when results look truncated.' },
+                            threshold: { type: 'number', description: `Max cosine distance (0–1). Lower = stricter. Default: ${this.config.search.similarityThreshold}. Use a lower value (e.g. 0.35) to filter out weak matches.` },
                         },
                         required: ['query'],
                     },
@@ -164,13 +158,13 @@ class McpServer {
                 },
                 {
                     name: 'find_symbol',
-                    description: 'Find TypeScript/JavaScript symbol definitions (functions, classes, types, interfaces, variables) by exact name. Use when you know the symbol name and want its definition location fast.',
+                    description: 'Find TypeScript/JavaScript symbol definitions (functions, classes, types, interfaces, variables, methods) by exact name. Use when you know the symbol name and want its definition location fast.',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             name: { type: 'string', description: 'Exact symbol name (case-sensitive, whole-word match)' },
                             project: { type: 'string', description: 'Limit search to this project (optional). Use list_projects to find names.' },
-                            kind: { type: 'string', enum: ['function', 'class', 'type', 'interface', 'variable', 'all'], description: 'Symbol kind filter. Default: all.' },
+                            kind: { type: 'string', enum: ['function', 'class', 'type', 'interface', 'variable', 'method', 'all'], description: 'Symbol kind filter. Default: all.' },
                         },
                         required: ['name'],
                     },
@@ -204,6 +198,14 @@ class McpServer {
             ],
         }));
         server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
+            if (startupError) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `MCP server is unavailable: ${startupError.message}\n\nCheck the log file and fix the issue, then restart the MCP server.`,
+                        }],
+                };
+            }
             try {
                 if (req.params.name === 'list_projects') {
                     const rows = await this.searcher.listProjects();
@@ -232,8 +234,13 @@ class McpServer {
                     const limit = Math.min(Math.max(1, Number(req.params.arguments?.limit) || this.config.search.defaultLimit), this.config.search.maxLimit);
                     const project = req.params.arguments?.project ? String(req.params.arguments.project) : null;
                     const includeNeighbors = Boolean(req.params.arguments?.include_neighbors);
+                    const rawThreshold = req.params.arguments?.threshold;
+                    const parsedThreshold = Number(rawThreshold);
+                    const threshold = rawThreshold != null && !isNaN(parsedThreshold)
+                        ? Math.min(1, Math.max(0, parsedThreshold))
+                        : undefined;
                     const { query, translated } = await this.searcher.prepareQuery(raw);
-                    const results = await this.searcher.searchChunks(query, limit, project);
+                    const results = await this.searcher.searchChunks(query, limit, project, threshold);
                     if (results.length === 0) {
                         return { content: [{ type: 'text', text: 'No relevant results found.' }] };
                     }
@@ -318,7 +325,7 @@ class McpServer {
                     const name = String(req.params.arguments?.name ?? '');
                     const project = req.params.arguments?.project ? String(req.params.arguments.project) : null;
                     const rawKind = req.params.arguments?.kind;
-                    const validKinds = ['function', 'class', 'type', 'interface', 'variable', 'all'];
+                    const validKinds = ['function', 'class', 'type', 'interface', 'variable', 'method', 'all'];
                     const kind = validKinds.includes(rawKind) ? rawKind : 'all';
                     const { hits, truncated } = await this.searcher.findSymbol(name, project, kind);
                     if (hits.length === 0) {

package/dist/src/services/SearcherService.d.ts

@@ -45,7 +45,7 @@ export interface GrepMatch {
     filePath: string;
     line: number;
 }
-export type SymbolKind = 'function' | 'class' | 'type' | 'interface' | 'variable' | 'all';
+export type SymbolKind = 'function' | 'class' | 'type' | 'interface' | 'variable' | 'method' | 'all';
 export interface SymbolHit {
     filePath: string;
     line: number;
@@ -64,7 +64,7 @@ export declare class SearcherService {
         translated: boolean;
     }>;
     listProjects(): Promise<ProjectRow[]>;
-    searchChunks(query: string, limit: number, project: string | null): Promise<SearchResult[]>;
+    searchChunks(query: string, limit: number, project: string | null, threshold?: number): Promise<SearchResult[]>;
     fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
     getDependencies(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
     getDependents(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;

package/dist/src/services/SearcherService.js

@@ -59,8 +59,11 @@ class SearcherService {
     }
     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 };
+            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) });
+            return { query, translated: true };
         }
+        this.logger.debug('SearcherService: prepareQuery', { translated: false, query: raw.slice(0, 120) });
         return { query: raw, translated: false };
     }
     async listProjects() {
@@ -73,25 +76,36 @@ class SearcherService {
             return { ...r, ...(typeof meta === 'object' ? meta : EMPTY_META) };
         });
     }
-    async searchChunks(query, limit, project) {
+    async searchChunks(query, limit, project, threshold) {
+        const effectiveThreshold = threshold ?? this.config.search.similarityThreshold;
+        this.logger.debug('SearcherService: searchChunks', {
+            query: query.slice(0, 120), limit, project, threshold: effectiveThreshold,
+        });
         const embedding = await this.embedder.embed(query);
-        const params = [`[${embedding}]`, this.config.search.similarityThreshold, limit];
+        const params = [`[${embedding}]`, effectiveThreshold, limit];
         let projectFilter = '';
         if (project) {
             params.push(project);
             projectFilter = `AND "serviceName" = $${params.length}`;
         }
-        return this.db.query(`SELECT "serviceName", "filePath", "startLine", content,
+        const results = 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),
+        });
+        return results;
     }
     async fetchNeighbors(results) {
         if (results.length === 0)
             return [];
+        this.logger.debug('SearcherService: fetchNeighbors', { count: results.length });
         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,
@@ -109,13 +123,19 @@ class SearcherService {
          ORDER BY "startLine" ASC LIMIT 1
        ) next ON true
        ORDER BY r.idx`, params);
-        return rows.map((row, i) => ({
+        const neighbors = 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,
         }));
+        this.logger.debug('SearcherService: fetchNeighbors results', {
+            withPrev: neighbors.filter(n => n.prevChunk).length,
+            withNext: neighbors.filter(n => n.nextChunk).length,
+        });
+        return neighbors;
     }
     async getDependencies(filePath, project, symbol = null, transitive = false) {
+        this.logger.debug('SearcherService: getDependencies', { filePath, project, symbol, transitive });
         const params = [filePath, project];
         let symbolFilter = '';
         if (symbol) {
@@ -127,8 +147,10 @@ class SearcherService {
        WHERE "fromFile" = $1 AND project = $2
        ${symbolFilter}
        ORDER BY "toFile"`, params);
-        if (!transitive)
+        if (!transitive) {
+            this.logger.debug('SearcherService: getDependencies result', { direct: direct.length });
             return direct;
+        }
         const indirect = await this.db.query(`WITH RECURSIVE deps AS (
          SELECT "toFile", 1 AS depth, "toFile" AS via
          FROM code_dependency
@@ -151,9 +173,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 });
         return [...direct, ...indirect];
     }
     async getDependents(filePath, project, symbol = null, transitive = false) {
+        this.logger.debug('SearcherService: getDependents', { filePath, project, symbol, transitive });
         const params = [filePath, project];
         let symbolFilter = '';
         if (symbol) {
@@ -165,8 +189,10 @@ class SearcherService {
        WHERE "toFile" = $1 AND project = $2
        ${symbolFilter}
        ORDER BY "fromFile"`, params);
-        if (!transitive)
+        if (!transitive) {
+            this.logger.debug('SearcherService: getDependents result', { direct: direct.length });
             return direct;
+        }
         const indirect = await this.db.query(`WITH RECURSIVE rdeps AS (
          SELECT "fromFile", 1 AS depth, "fromFile" AS via
          FROM code_dependency
@@ -189,9 +215,11 @@ 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 });
         return [...direct, ...indirect];
     }
     grepSymbol(symbol, project, excludeFile) {
+        this.logger.debug('SearcherService: grepSymbol', { symbol, project, excludeFile });
         const projectDir = path.join(this.config.workspaceRoot, project);
         const result = (0, child_process_1.spawnSync)('grep', [
             '-rn', '-F', '-w',
@@ -216,16 +244,21 @@ class SearcherService {
                 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 };
+        const truncated = all.length > GREP_MAX_RESULTS;
+        this.logger.debug('SearcherService: grepSymbol result', { matches: Math.min(all.length, GREP_MAX_RESULTS), truncated });
+        return { matches: all.slice(0, GREP_MAX_RESULTS), truncated };
     }
     // Sync wrapper: validates name (throws synchronously), then returns Promise.
-    // Falls back to grep when the symbol index (code_symbol table) is unavailable.
+    // Methods are never indexed — always resolved via grep. Other kinds use index with grep fallback.
     findSymbol(name, project, kind) {
         if (!/^[\w$]+$/.test(name))
             throw new Error('Invalid symbol name');
+        if (kind === 'method')
+            return Promise.resolve(this.grepFindSymbol(name, project, kind));
         return this.findSymbolFromIndex(name, project, kind);
     }
     async findSymbolFromIndex(name, project, kind) {
+        this.logger.debug('SearcherService: findSymbol', { name, project, kind, source: 'index' });
         try {
             const params = [name];
             let projectFilter = '';
@@ -252,6 +285,7 @@ class SearcherService {
                 kind: row.kind,
                 signature: row.signature ?? row.name,
             }));
+            this.logger.debug('SearcherService: findSymbol result', { source: 'index', hits: hits.length, truncated });
             return { hits, truncated };
         }
         catch {
@@ -260,6 +294,7 @@ class SearcherService {
         }
     }
     grepFindSymbol(name, project, kind) {
+        this.logger.debug('SearcherService: findSymbol', { name, project, kind, source: 'grep' });
         const searchDir = project
             ? path.join(this.config.workspaceRoot, project)
             : this.config.workspaceRoot;
@@ -300,9 +335,11 @@ class SearcherService {
                 signature: matchedLine.trim(),
             });
         }
+        this.logger.debug('SearcherService: findSymbol result', { source: 'grep', hits: hits.length, truncated: hits.length >= FIND_SYMBOL_LIMIT });
         return { hits, truncated: hits.length >= FIND_SYMBOL_LIMIT };
     }
     listFiles(relativePath, project, depth, pattern) {
+        this.logger.debug('SearcherService: listFiles', { relativePath, project, depth, pattern });
         const projectRoot = path.join(this.config.workspaceRoot, project);
         const resolvedTarget = path.resolve(projectRoot, relativePath);
         const resolvedProject = path.resolve(projectRoot);
@@ -318,12 +355,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 });
         if (lines.length === 0) {
             return { tree: pattern ? `No files matching "${pattern}" found.` : '(empty directory)' };
         }
         return { tree: lines.join('\n') };
     }
     async readFileAbsolute(absPath, maxLines) {
+        this.logger.debug('SearcherService: readFileAbsolute', { absPath, maxLines });
         const resolvedRoot = path.resolve(this.config.workspaceRoot);
         const resolved = path.resolve(absPath);
         if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + path.sep)) {
@@ -356,9 +395,11 @@ class SearcherService {
             throw err;
         }
         const relPath = path.relative(resolvedRoot, resolved);
+        this.logger.debug('SearcherService: readFileAbsolute result', { linesRead: lines.length, hasMore });
         return { ok: true, filePath: relPath, startLine: 1, endLine: lines.length, lines, hasMore };
     }
     async readFileRange(filePath, startLine, endLine) {
+        this.logger.debug('SearcherService: 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)) {
@@ -388,6 +429,7 @@ class SearcherService {
                 break;
             }
         }
+        this.logger.debug('SearcherService: readFileRange result', { linesRead: lines.length, hasMore });
         return { ok: true, filePath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
     }
     isNonEnglish(text) {
@@ -432,6 +474,7 @@ class SearcherService {
             type: `(export[[:space:]]+)?type[[:space:]]+${name}[[:space:]=<]`,
             interface: `(export[[:space:]]+)?interface[[:space:]]+${name}[[:space:]{<]`,
             variable: `(export[[:space:]]+)?(const|let|var)[[:space:]]+${name}[[:space:]=:]`,
+            method: `(public[[:space:]]+|async[[:space:]]+|static[[:space:]]+|override[[:space:]]+)+(async[[:space:]]+)?${name}[[:space:]]*[(<]`,
         };
         if (kind === 'all')
             return Object.values(patterns).join('|');
@@ -447,6 +490,8 @@ class SearcherService {
             return 'interface';
         if (/\btype\s+$/.test(before))
             return 'type';
+        if (/\b(public|async|static|override)\s+$/.test(before))
+            return 'method';
         return 'variable';
     }
 }

package/dist/src/setup.d.ts

@@ -1 +1,2 @@
-export declare function runSetup(): Promise<void>;
+import type { LoggerService } from './services/LoggerService';
+export declare function runSetup(logger?: LoggerService): Promise<void>;

package/dist/src/setup.js

@@ -41,6 +41,7 @@ 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');
@@ -64,7 +65,7 @@ function writeEnv(vars) {
     fs.writeFileSync(CONFIG_FILE, content, { mode: 0o600 });
     console.log(`\nConfig saved to ${CONFIG_FILE}`);
 }
-async function waitForDb(host, port, user, pass, db, maxWaitSec = 60) {
+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;
     process.stdout.write('Waiting for PostgreSQL to be ready');
@@ -81,10 +82,12 @@ async function waitForDb(host, port, user, pass, db, maxWaitSec = 60) {
             await new Promise(r => setTimeout(r, 2000));
         }
     }
-    console.error('\nPostgreSQL did not become ready in time.');
+    const reason = 'PostgreSQL did not become ready in time.';
+    console.error(`\n${reason}`);
+    logger?.error('waitForDb: timeout', { reason, steps });
     process.exit(1);
 }
-async function waitForOllama(host, maxWaitSec = 60) {
+async function waitForOllama(host, maxWaitSec = 60, logger, steps) {
     const deadline = Date.now() + maxWaitSec * 1000;
     process.stdout.write('Waiting for Ollama to be ready');
     while (Date.now() < deadline) {
@@ -106,10 +109,12 @@ async function waitForOllama(host, maxWaitSec = 60) {
             await new Promise(r => setTimeout(r, 2000));
         }
     }
-    console.error('\nOllama did not become ready in time.');
+    const reason = 'Ollama did not become ready in time.';
+    console.error(`\n${reason}`);
+    logger?.error('waitForOllama: timeout', { reason, steps });
     process.exit(1);
 }
-async function checkRemoteDb(host, port, user, pass, db) {
+async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
     try {
         const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
         const client = new Client({ host, port: parseInt(port), user, password: pass, database: db, connectionTimeoutMillis: 5000 });
@@ -118,50 +123,62 @@ async function checkRemoteDb(host, port, user, pass, db) {
         return true;
     }
     catch (err) {
-        console.error(`  Connection failed: ${err.message}`);
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  Connection failed: ${msg}`);
+        logger?.error('checkRemoteDb: connection failed', { reason: msg, steps });
         return false;
     }
 }
-async function setupLocalDocker(ollamaHost) {
-    console.log('\nCopying docker-compose.yml to', DOCKER_COMPOSE_DST);
+async function setupLocalDocker(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');
+    composeContent = composeContent
+        .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.copyFileSync(DOCKER_COMPOSE_SRC, DOCKER_COMPOSE_DST);
+    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) {
-        console.error('Failed to start Docker containers. Make sure Docker is running.');
+        const reason = 'Failed to start Docker containers. Make sure Docker is running.';
+        console.error(reason);
+        logger?.error('setupLocalDocker: docker startup failed', { reason, steps });
         process.exit(1);
     }
-    await waitForDb('localhost', 5433, 'dev', 'dev', 'postgres');
-    await waitForOllama(ollamaHost);
+    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) {
-        console.error('Could not resolve ollama container ID from compose. Pull the model manually:');
+        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 });
         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: '5433',
-        DB_USER: 'dev',
-        DB_PASS: 'dev',
-    };
+    return { DB_HOST: 'localhost', DB_PORT: dbPort, DB_USER: dbUser, DB_PASS: dbPass };
 }
-async function setupRemoteDb(rl) {
+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 prompt(rl, 'DB host', 'localhost');
-        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_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');
+        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;
@@ -172,18 +189,47 @@ async function setupRemoteDb(rl) {
     }
     return vars;
 }
-async function runSetup() {
+async function runSetup(logger) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    console.log('=== codesearch-mcp setup ===\n');
-    const dbChoice = await ask(rl, 'Infrastructure:\n  1. Local Docker (auto-start PostgreSQL + Ollama)\n  2. Remote (Supabase, Railway, self-hosted DB + local Ollama)\n\nEnter choice (1): ');
+    const steps = [];
+    function logStep(q, raw) {
+        const a = /password/i.test(q) ? '***' : raw.trim();
+        logger?.debug('setup: prompt', { q, a });
+        steps.push({ q, a });
+    }
+    const loggedAsk = async (question) => {
+        const answer = await ask(rl, question);
+        const key = question.split('\n').find(l => l.trim())?.trim() ?? question.trim();
+        logStep(key, answer);
+        return answer;
+    };
+    const loggedPrompt = async (label, def) => {
+        const answer = await prompt(rl, label, def);
+        logStep(label, answer || def);
+        return answer;
+    };
+    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 defaultWorkspace = path.join(os.homedir(), 'Projects');
-    const workspaceInput = await ask(rl, `\nWorkspace root — directory that contains all your projects\n  Example: ${os.homedir()}/WebstormProjects\n  Path (${defaultWorkspace}): `);
-    const workspaceRoot = expandHome(workspaceInput.trim() || defaultWorkspace);
-    const ollamaHost = await prompt(rl, 'Ollama API URL', 'http://localhost:11434');
+    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(`  (e.g. ${workspaceExample})`);
+    let workspaceInput;
+    do {
+        workspaceInput = await loggedAsk('Path: ');
+        if (!workspaceInput.trim())
+            console.log('  Path is required.');
+    } 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 setupRemoteDb(rl);
+        ? 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--- Logging ---');
     console.log('  error  — failures only (recommended)');
     console.log('  warn   — + recoverable issues');
@@ -191,20 +237,21 @@ async function runSetup() {
     const validLevels = ['error', 'warn', 'info', 'debug'];
     let logLevel;
     do {
-        logLevel = await prompt(rl, 'Log level (error/warn/info/debug)', 'error');
+        logLevel = await loggedPrompt('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({
+    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,
-        LOG_FILE: logFile,
-    });
+    };
+    if (logDir)
+        envVars['LOG_DIR'] = logDir;
+    writeEnv(envVars);
     rl.close();
     console.log('\nInitializing database schema...');
     const dotenv = await Promise.resolve().then(() => __importStar(require('dotenv')));
@@ -212,8 +259,21 @@ async function runSetup() {
     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();
+    let initError = null;
+    try {
+        await dbService.initDbWithSchema();
+    }
+    catch (err) {
+        initError = err instanceof Error ? err : new Error(String(err));
+    }
+    finally {
+        await dbService.destroy();
+    }
+    if (initError) {
+        console.error(`Database schema init failed: ${initError.message}`);
+        logger?.error('runSetup: database schema init failed', { reason: initError.message, steps });
+        process.exit(1);
+    }
     console.log('\nSetup complete!');
     console.log('\nNext steps:');
     console.log(`  rag-index ${workspaceRoot}`);

package/docker/docker-compose.yml

@@ -6,7 +6,7 @@ services:
     environment:
       POSTGRES_USER: dev
       POSTGRES_PASSWORD: dev
-      POSTGRES_DB: rag
+      POSTGRES_DB: postgres
     ports:
       - "5433:5432"
     volumes:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codesearch-mcp",
-  "version": "0.0.12-alpha",
+  "version": "0.0.14-alpha",
   "description": "Local semantic codebase search via MCP — indexes projects into pgvector, exposes search to Claude",
   "license": "MIT",
   "main": "dist/app.js",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.4.1",
-    "@langchain/textsplitters": "^0.1.0",
+    "@langchain/textsplitters": "^1.0.1",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "cli-progress": "^3.12.0",
     "dotenv": "^17.4.2",
@@ -37,6 +37,7 @@
     "ollama": "^0.5.0",
     "pg": "^8.13.0",
     "pino": "^10.3.1",
+    "pino-roll": "^4.0.0",
     "reflect-metadata": "^0.2.2",
     "ts-morph": "^28.0.0",
     "typeorm": "^0.3.20",