codesearch-mcp 0.0.15-alpha → 0.0.17-alpha

package/dist/src/config-store.js

@@ -0,0 +1,197 @@
+"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.ALL_KEYS = exports.CONFIG_FILE = exports.CONFIG_DIR = void 0;
+exports.readConfigJson = readConfigJson;
+exports.writeConfigJson = writeConfigJson;
+exports.getNestedValue = getNestedValue;
+exports.setNestedValue = setNestedValue;
+exports.deleteNestedValue = deleteNestedValue;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const zod_1 = require("zod");
+exports.CONFIG_DIR = path.join(os.homedir(), '.config', 'codesearch-mcp');
+exports.CONFIG_FILE = path.join(exports.CONFIG_DIR, 'config.json');
+// All fields optional — defaults live in config.ts. The file stays minimal.
+const jsonSchema = zod_1.z.object({
+    db: zod_1.z.object({
+        host: zod_1.z.string().optional(),
+        port: zod_1.z.number().optional(),
+        user: zod_1.z.string().optional(),
+        password: zod_1.z.string().optional(),
+        name: zod_1.z.string().optional(),
+    }).optional(),
+    ollama: zod_1.z.object({
+        host: zod_1.z.string().optional(),
+        model: zod_1.z.string().optional(),
+    }).optional(),
+    indexing: zod_1.z.object({
+        chunkSize: zod_1.z.number().optional(),
+        chunkOverlap: zod_1.z.number().optional(),
+        embedBatchSize: zod_1.z.number().optional(),
+        astBatchSize: zod_1.z.number().optional(),
+    }).optional(),
+    search: zod_1.z.object({
+        similarityThreshold: zod_1.z.number().optional(),
+        defaultLimit: zod_1.z.number().optional(),
+        maxLimit: zod_1.z.number().optional(),
+        autoTranslate: zod_1.z.boolean().optional(),
+        translateModel: zod_1.z.string().optional(),
+    }).optional(),
+    reranker: zod_1.z.object({
+        enabled: zod_1.z.boolean().optional(),
+        model: zod_1.z.string().optional(),
+        url: zod_1.z.string().optional(),
+        overfetch: zod_1.z.number().int().min(1).max(20).optional(),
+    }).optional(),
+    logging: zod_1.z.object({
+        level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).optional(),
+        dir: zod_1.z.string().optional(),
+    }).optional(),
+    workspaceRoot: zod_1.z.string().optional(),
+});
+const FIELD_TYPES = {
+    'db.host': 'string',
+    'db.port': 'number',
+    'db.user': 'string',
+    'db.password': 'string',
+    'db.name': 'string',
+    'ollama.host': 'string',
+    'ollama.model': 'string',
+    'indexing.chunkSize': 'number',
+    'indexing.chunkOverlap': 'number',
+    'indexing.embedBatchSize': 'number',
+    'indexing.astBatchSize': 'number',
+    'search.similarityThreshold': 'number',
+    'search.defaultLimit': 'number',
+    'search.maxLimit': 'number',
+    'search.autoTranslate': 'boolean',
+    'search.translateModel': 'string',
+    'reranker.enabled': 'boolean',
+    'reranker.model': 'string',
+    'reranker.url': 'string',
+    'reranker.overfetch': 'number',
+    'logging.level': 'string',
+    'logging.dir': 'string',
+    'workspaceRoot': 'string',
+};
+exports.ALL_KEYS = Object.keys(FIELD_TYPES);
+function readConfigJson() {
+    if (!fs.existsSync(exports.CONFIG_FILE))
+        return null;
+    let raw;
+    try {
+        raw = fs.readFileSync(exports.CONFIG_FILE, 'utf-8');
+    }
+    catch (e) {
+        throw new Error(`Cannot read ${exports.CONFIG_FILE}: ${e.message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`Invalid JSON in ${exports.CONFIG_FILE}: ${e.message}\n` +
+            `Fix the file manually or delete it and run: rag-setup`);
+    }
+    const result = jsonSchema.safeParse(parsed);
+    if (!result.success) {
+        const issues = result.error.issues.map(i => `  ${i.path.join('.')}: ${i.message}`).join('\n');
+        throw new Error(`Invalid config in ${exports.CONFIG_FILE}:\n${issues}\n` +
+            `Fix with: rag-config set <key> <value>`);
+    }
+    return result.data;
+}
+function writeConfigJson(data) {
+    fs.mkdirSync(exports.CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(exports.CONFIG_FILE, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+}
+function getNestedValue(cfg, key) {
+    const parts = key.split('.');
+    let cur = cfg;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== 'object')
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+function coerceValue(key, raw) {
+    const type = FIELD_TYPES[key];
+    if (type === 'number') {
+        const n = Number(raw);
+        if (raw.trim() === '' || isNaN(n))
+            throw new Error(`${key} must be a number, got: ${raw}`);
+        return n;
+    }
+    if (type === 'boolean') {
+        if (raw !== 'true' && raw !== 'false')
+            throw new Error(`${key} must be "true" or "false", got: ${raw}`);
+        return raw === 'true';
+    }
+    return raw;
+}
+function setNestedValue(cfg, key, raw) {
+    if (!FIELD_TYPES[key])
+        throw new Error(`Unknown config key: ${key}\nValid keys: ${exports.ALL_KEYS.join(', ')}`);
+    const value = coerceValue(key, raw);
+    const parts = key.split('.');
+    const clone = JSON.parse(JSON.stringify(cfg));
+    if (parts.length === 1) {
+        clone[parts[0]] = value;
+    }
+    else {
+        if (typeof clone[parts[0]] !== 'object' || !clone[parts[0]])
+            clone[parts[0]] = {};
+        clone[parts[0]][parts[1]] = value;
+    }
+    return clone;
+}
+function deleteNestedValue(cfg, key) {
+    if (!FIELD_TYPES[key])
+        throw new Error(`Unknown config key: ${key}`);
+    const parts = key.split('.');
+    const clone = JSON.parse(JSON.stringify(cfg));
+    if (parts.length === 1) {
+        delete clone[parts[0]];
+    }
+    else if (clone[parts[0]] && typeof clone[parts[0]] === 'object') {
+        delete clone[parts[0]][parts[1]];
+        if (Object.keys(clone[parts[0]]).length === 0)
+            delete clone[parts[0]];
+    }
+    return clone;
+}

package/dist/src/config.d.ts

@@ -1,27 +1,41 @@
-export declare const config: {
-    db: {
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+export declare class Config {
+    private readonly data;
+    get db(): {
         host: string;
         port: number;
         username: string;
         password: string;
         database: string;
     };
-    ollama: {
+    get ollama(): {
         host: string;
         model: string;
+        rerankerModel: string;
+        rerankerUrl: string;
     };
-    indexer: {
+    get indexer(): {
         chunkSize: number;
         chunkOverlap: number;
         batchSize: number;
+        astBatchSize: number;
     };
-    search: {
+    get search(): {
         similarityThreshold: number;
         defaultLimit: number;
         maxLimit: number;
         autoTranslate: boolean;
         translateModel: string;
+        rerankerEnabled: boolean;
+        rerankerOverfetch: number;
     };
-    workspaceRoot: string;
-};
-export type Config = typeof config;
+    get logging(): {
+        level: "error" | "debug" | "info" | "warn";
+        dir?: string | undefined;
+    };
+    get workspaceRoot(): string;
+    constructor();
+    private deriveDbName;
+}

package/dist/src/config.js

@@ -33,68 +33,113 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.config = void 0;
+exports.Config = exports.ConfigError = void 0;
 const os = __importStar(require("os"));
 const zod_1 = require("zod");
+const config_store_1 = require("./config-store");
 const constants_1 = require("./constants");
-function deriveDbName() {
-    const username = os.userInfo().username;
-    const sanitized = username.toLowerCase().replace(/[^a-z0-9_]/g, '_');
-    return 'rag_' + (sanitized || 'user');
+class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigError';
+    }
 }
-const schema = zod_1.z.object({
-    // required — no defaults, process exits if missing
-    DB_HOST: zod_1.z.string(),
-    DB_PORT: zod_1.z.coerce.number().default(5433),
-    DB_USER: zod_1.z.string(),
-    DB_PASS: zod_1.z.string(),
-    DB_NAME: zod_1.z.string().optional(),
-    // optional with defaults
-    OLLAMA_HOST: zod_1.z.string().url().default('http://localhost:11434'),
-    OLLAMA_MODEL: zod_1.z.string().default(constants_1.DEFAULT_EMBED_MODEL),
-    CHUNK_SIZE: zod_1.z.coerce.number().default(1500),
-    CHUNK_OVERLAP: zod_1.z.coerce.number().default(200),
-    EMBED_BATCH_SIZE: zod_1.z.coerce.number().default(5),
-    SIMILARITY_THRESHOLD: zod_1.z.coerce.number().default(0.6),
-    SEARCH_DEFAULT_LIMIT: zod_1.z.coerce.number().default(5),
-    SEARCH_MAX_LIMIT: zod_1.z.coerce.number().default(20),
-    // auto-translate non-English queries to English before embedding
-    AUTO_TRANSLATE: zod_1.z.string().default('false').transform(v => v === 'true'),
-    TRANSLATE_MODEL: zod_1.z.string().default('llama3.2'),
-    WORKSPACE_ROOT: zod_1.z.string().optional(),
+exports.ConfigError = ConfigError;
+const resolvedSchema = zod_1.z.object({
+    db: zod_1.z.object({
+        host: zod_1.z.string().min(1, 'required — run rag-setup'),
+        port: zod_1.z.number().int().positive().default(5433),
+        username: zod_1.z.string().min(1, 'required — run rag-setup'),
+        password: zod_1.z.string().min(1, 'required — run rag-setup'),
+        database: zod_1.z.string().min(1),
+    }),
+    ollama: zod_1.z.object({
+        host: zod_1.z.string().min(1).default('http://localhost:11434'),
+        model: zod_1.z.string().min(1).default(constants_1.DEFAULT_EMBED_MODEL),
+        rerankerModel: zod_1.z.string().default(''),
+        rerankerUrl: zod_1.z.string().min(1),
+    }),
+    indexer: zod_1.z.object({
+        chunkSize: zod_1.z.number().int().positive().default(1500),
+        chunkOverlap: zod_1.z.number().int().min(0).default(200),
+        batchSize: zod_1.z.number().int().positive().default(5),
+        astBatchSize: zod_1.z.number().int().positive().default(3000),
+    }),
+    search: zod_1.z.object({
+        similarityThreshold: zod_1.z.number().min(0).max(1).default(0.6),
+        defaultLimit: zod_1.z.number().int().positive().default(5),
+        maxLimit: zod_1.z.number().int().positive().default(20),
+        autoTranslate: zod_1.z.boolean().default(false),
+        translateModel: zod_1.z.string().default('llama3.2'),
+        rerankerEnabled: zod_1.z.boolean().default(false),
+        rerankerOverfetch: zod_1.z.number().int().min(1).max(20).default(3),
+    }),
+    logging: zod_1.z.object({
+        level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).default('error'),
+        dir: zod_1.z.string().optional(),
+    }),
+    workspaceRoot: zod_1.z.string().default(''),
 });
-const parsed = schema.safeParse(process.env);
-if (!parsed.success) {
-    console.error('Invalid or missing config:');
-    for (const [key, errors] of Object.entries(parsed.error.flatten().fieldErrors)) {
-        console.error(`  ${key}: ${errors.join(', ')}`);
+class Config {
+    data;
+    get db() { return this.data.db; }
+    get ollama() { return this.data.ollama; }
+    get indexer() { return this.data.indexer; }
+    get search() { return this.data.search; }
+    get logging() { return this.data.logging; }
+    get workspaceRoot() { return this.data.workspaceRoot; }
+    constructor() {
+        const raw = (0, config_store_1.readConfigJson)();
+        if (!raw)
+            throw new ConfigError('Config not found. Run rag-setup.');
+        const ollamaHost = raw.ollama?.host ?? 'http://localhost:11434';
+        const result = resolvedSchema.safeParse({
+            db: {
+                host: raw.db?.host,
+                port: raw.db?.port,
+                username: raw.db?.user,
+                password: raw.db?.password,
+                database: raw.db?.name ?? this.deriveDbName(),
+            },
+            ollama: {
+                host: raw.ollama?.host,
+                model: raw.ollama?.model,
+                rerankerModel: raw.reranker?.model,
+                rerankerUrl: raw.reranker?.url ?? `${ollamaHost}/api/rerank`,
+            },
+            indexer: {
+                chunkSize: raw.indexing?.chunkSize,
+                chunkOverlap: raw.indexing?.chunkOverlap,
+                batchSize: raw.indexing?.embedBatchSize,
+                astBatchSize: raw.indexing?.astBatchSize,
+            },
+            search: {
+                similarityThreshold: raw.search?.similarityThreshold,
+                defaultLimit: raw.search?.defaultLimit,
+                maxLimit: raw.search?.maxLimit,
+                autoTranslate: raw.search?.autoTranslate,
+                translateModel: raw.search?.translateModel,
+                rerankerEnabled: raw.reranker?.enabled,
+                rerankerOverfetch: raw.reranker?.overfetch,
+            },
+            logging: {
+                level: raw.logging?.level,
+                dir: raw.logging?.dir,
+            },
+            workspaceRoot: raw.workspaceRoot,
+        });
+        if (!result.success) {
+            const issues = result.error.issues
+                .map(i => `  ${i.path.join('.')}: ${i.message}`)
+                .join('\n');
+            throw new ConfigError(`Invalid config:\n${issues}\nRun rag-setup or: rag-config set <key> <value>`);
+        }
+        this.data = result.data;
+    }
+    deriveDbName() {
+        const username = os.userInfo().username;
+        const sanitized = username.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        return 'rag_' + (sanitized || 'user');
     }
-    process.exit(1);
 }
-const env = parsed.data;
-exports.config = {
-    db: {
-        host: env.DB_HOST,
-        port: env.DB_PORT,
-        username: env.DB_USER,
-        password: env.DB_PASS,
-        database: env.DB_NAME ?? deriveDbName(),
-    },
-    ollama: {
-        host: env.OLLAMA_HOST,
-        model: env.OLLAMA_MODEL,
-    },
-    indexer: {
-        chunkSize: env.CHUNK_SIZE,
-        chunkOverlap: env.CHUNK_OVERLAP,
-        batchSize: env.EMBED_BATCH_SIZE,
-    },
-    search: {
-        similarityThreshold: env.SIMILARITY_THRESHOLD,
-        defaultLimit: env.SEARCH_DEFAULT_LIMIT,
-        maxLimit: env.SEARCH_MAX_LIMIT,
-        autoTranslate: env.AUTO_TRANSLATE,
-        translateModel: env.TRANSLATE_MODEL,
-    },
-    workspaceRoot: env.WORKSPACE_ROOT ?? '',
-};
+exports.Config = Config;

package/dist/src/container.d.ts

@@ -1,4 +1,4 @@
-import { type Config } from './config';
+import { Config } from './config';
 import { DatabaseService } from './services/DatabaseService';
 import { IndexerService } from './services/IndexerService';
 import { SearcherService } from './services/SearcherService';

package/dist/src/container.js

@@ -10,12 +10,13 @@ const SearcherService_1 = require("./services/SearcherService");
 const McpServer_1 = require("./services/McpServer");
 const LoggerService_1 = require("./services/LoggerService");
 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 config = new config_1.Config();
+    const logger = LoggerService_1.LoggerService.fromConfig(config.logging, loggerName);
+    const db = new DatabaseService_1.DatabaseService(config);
+    const embedder = new OllamaEmbedder_1.OllamaEmbedder(config);
     const ast = new AstParserService_1.AstParserService(logger);
-    const indexer = new IndexerService_1.IndexerService(db, embedder, ast, config_1.config, logger);
-    const searcher = new SearcherService_1.SearcherService(db, embedder, config_1.config, logger);
-    const mcp = new McpServer_1.McpServer(searcher, config_1.config, logger);
-    return { config: config_1.config, db, indexer, searcher, mcp, logger };
+    const indexer = new IndexerService_1.IndexerService(db, embedder, ast, config, logger);
+    const searcher = new SearcherService_1.SearcherService(db, embedder, config, logger);
+    const mcp = new McpServer_1.McpServer(searcher, config, logger);
+    return { config, db, indexer, searcher, mcp, logger };
 }

package/dist/src/db/index.d.ts

@@ -1,3 +1,2 @@
-export { CodeChunk } from './entities/code-chunk.entity';
-export { CodeDependency } from './entities/code-dependency.entity';
-export { CodeSymbol } from './entities/code-symbol.entity';
+export { codeChunk, codeDependency, codeSymbol, codeCall } from './schema';
+export type { CodeChunkInsert } from './schema';

package/dist/src/db/index.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeSymbol = exports.CodeDependency = exports.CodeChunk = void 0;
-var code_chunk_entity_1 = require("./entities/code-chunk.entity");
-Object.defineProperty(exports, "CodeChunk", { enumerable: true, get: function () { return code_chunk_entity_1.CodeChunk; } });
-var code_dependency_entity_1 = require("./entities/code-dependency.entity");
-Object.defineProperty(exports, "CodeDependency", { enumerable: true, get: function () { return code_dependency_entity_1.CodeDependency; } });
-var code_symbol_entity_1 = require("./entities/code-symbol.entity");
-Object.defineProperty(exports, "CodeSymbol", { enumerable: true, get: function () { return code_symbol_entity_1.CodeSymbol; } });
+exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "codeChunk", { enumerable: true, get: function () { return schema_1.codeChunk; } });
+Object.defineProperty(exports, "codeDependency", { enumerable: true, get: function () { return schema_1.codeDependency; } });
+Object.defineProperty(exports, "codeSymbol", { enumerable: true, get: function () { return schema_1.codeSymbol; } });
+Object.defineProperty(exports, "codeCall", { enumerable: true, get: function () { return schema_1.codeCall; } });