codesearch-mcp 0.0.1-alpha

package/README.md

@@ -0,0 +1,129 @@
+# codesearch-mcp
+
+Semantic codebase search for Claude. Indexes your local projects into a PostgreSQL vector database and exposes search via the Model Context Protocol (MCP).
+
+Ask Claude things like *"where is the payment retry logic?"* or *"show me how auth tokens are validated"* — across all your projects at once.
+
+> **Alpha** — works well locally, API may change before 1.0.
+
+## How it works
+
+1. `rag-index` scans your projects, chunks source files, embeds them with [bge-m3](https://huggingface.co/BAAI/bge-m3) via Ollama, and stores vectors in PostgreSQL
+2. `rag-mcp` exposes an MCP server — Claude calls it automatically when you ask about code
+3. Incremental — only changed files are re-indexed on subsequent runs
+
+**Stack:** TypeScript · TypeORM · PostgreSQL + pgvector · Ollama (bge-m3) · LangChain text splitters · ts-morph
+
+## Requirements
+
+- Node.js 18+
+- Docker (for local DB + Ollama) — or bring your own PostgreSQL with pgvector + Ollama
+
+## Installation
+
+```bash
+npm install -g codesearch-mcp
+```
+
+## Setup
+
+```bash
+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
+
+Config is saved to `~/.config/codesearch-mcp/.env`.
+
+## Index your projects
+
+```bash
+rag-index /home/user/Projects
+```
+
+On first run you will be prompted for each discovered project:
+
+```
+Found 5 new project(s). Select which to index:
+  y = yes  |  n = skip this time  |  s = always skip
+
+  myapp [y/n/s]: y
+  legacy-app [y/n/s]: s
+    → added to .ragskip
+```
+
+Selections are saved in `.ragprojects` / `.ragskip` at the workspace root. Use `--select` to revisit them.
+
+```bash
+rag-index /path --select          # re-run project selection
+rag-index /path --reindex         # force re-embed all files (use after model change)
+rag-index /path --select --reindex
+```
+
+## Register with Claude Code
+
+```bash
+claude mcp add codesearch-mcp -s user -- rag-mcp
+```
+
+Then ask Claude anything about your code — it will use `search_codebase`, `list_projects`, `read_file_range`, `get_dependencies`, and `get_dependents` automatically.
+
+## MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `search_codebase` | Semantic search across all indexed projects |
+| `list_projects` | List projects with metadata and chunk counts |
+| `read_file_range` | Read a specific line range from an indexed file |
+| `get_dependencies` | Show what files a given file imports |
+| `get_dependents` | Show which files import a given file |
+
+## Project metadata
+
+Add `.ragmeta.json` to a project root to enrich `list_projects` and generate a visual dependency graph:
+
+```json
+{
+  "description": "Main API server",
+  "stack": "NestJS, GraphQL, PostgreSQL",
+  "relations": {
+    "consumed_by": ["crm-frontend"],
+    "consumes": ["billing-service", "auth-service"]
+  }
+}
+```
+
+After each indexing run an interactive `project-graph.html` is written to the workspace root.
+
+## Excluding files
+
+Create `.ragignore` in a project root — same syntax as `.gitignore`:
+
+```
+src/gql/graphql.ts
+**/__snapshots__/**
+src/generated/
+```
+
+## Environment variables
+
+All set by `rag-setup`. Override any of them in `~/.config/codesearch-mcp/.env`.
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `DB_HOST` | — | PostgreSQL host |
+| `DB_PORT` | `5433` | PostgreSQL port |
+| `DB_USER` | — | PostgreSQL user |
+| `DB_PASS` | — | PostgreSQL password |
+| `DB_NAME` | — | Database name |
+| `WORKSPACE_ROOT` | — | Root of your projects directory |
+| `OLLAMA_HOST` | `http://localhost:11434` | Ollama API URL |
+| `OLLAMA_MODEL` | `bge-m3` | Embedding model |
+| `SIMILARITY_THRESHOLD` | `0.6` | Max cosine distance — raise if search returns nothing |
+| `AUTO_TRANSLATE` | `false` | Translate non-English queries to English before embedding |
+
+## License
+
+MIT

package/dist/app.d.ts

@@ -0,0 +1 @@
+import './src/env-loader';

package/dist/app.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+"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 });
+require("./src/env-loader");
+const path = __importStar(require("path"));
+const db_1 = require("./src/db");
+const indexer_1 = require("./src/indexer");
+const interrupt_1 = require("./src/interrupt");
+const project_selector_1 = require("./src/project-selector");
+const mcp_1 = require("./src/mcp");
+const graph_1 = require("./src/graph");
+function printSummary(allStats) {
+    const cols = { name: 30, num: 8 };
+    const line = '─'.repeat(cols.name + cols.num * 5 + 5);
+    console.log('\n=== Indexing Summary ===');
+    console.log('Service'.padEnd(cols.name), 'Indexed'.padStart(cols.num), 'Skipped'.padStart(cols.num), 'Failed'.padStart(cols.num), 'Chunks'.padStart(cols.num), 'Time(s)'.padStart(cols.num));
+    console.log(line);
+    for (const s of allStats) {
+        console.log(s.serviceName.padEnd(cols.name), String(s.indexed).padStart(cols.num), String(s.skipped).padStart(cols.num), String(s.failed).padStart(cols.num), String(s.chunks).padStart(cols.num), String(s.elapsedSec).padStart(cols.num));
+    }
+    console.log(line);
+    const total = allStats.reduce((acc, s) => ({
+        indexed: acc.indexed + s.indexed,
+        skipped: acc.skipped + s.skipped,
+        failed: acc.failed + s.failed,
+        chunks: acc.chunks + s.chunks,
+        elapsedSec: acc.elapsedSec + s.elapsedSec,
+    }), { indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0 });
+    console.log('TOTAL'.padEnd(cols.name), String(total.indexed).padStart(cols.num), String(total.skipped).padStart(cols.num), String(total.failed).padStart(cols.num), String(total.chunks).padStart(cols.num), String(total.elapsedSec.toFixed(1)).padStart(cols.num));
+}
+async function main() {
+    const argv1 = path.basename(process.argv[1] ?? '');
+    const isMcp = argv1 === 'rag-mcp' || process.argv[2] === 'mcp';
+    const isSetup = argv1 === 'rag-setup' || process.argv[2] === 'setup';
+    const mode = isMcp ? 'mcp' : isSetup ? 'setup' : (process.argv[2] ?? '');
+    if (mode === 'index') {
+        const args = process.argv.slice(argv1 === 'rag-index' ? 2 : 3);
+        const workspacePath = args.find(a => !a.startsWith('--'));
+        const force = args.includes('--reindex');
+        const forceSelect = args.includes('--select');
+        if (!workspacePath) {
+            console.error('Usage: rag-index <path> [--reindex] [--select]');
+            process.exit(1);
+        }
+        process.env.WORKSPACE_ROOT ??= workspacePath;
+        await (0, db_1.initDbWithSchema)();
+        (0, interrupt_1.setupInterrupt)();
+        const discovered = (0, indexer_1.discoverProjects)(workspacePath);
+        const projects = await (0, project_selector_1.selectProjects)(discovered, workspacePath, forceSelect);
+        if (projects.length === 0) {
+            (0, interrupt_1.teardownInterrupt)();
+            process.exit(0);
+        }
+        const allStats = [];
+        if (force)
+            console.log('Reindex mode: all files will be re-indexed.');
+        for (const proj of projects) {
+            if (interrupt_1.signal.aborted)
+                break;
+            const stats = await (0, indexer_1.scanAndIndex)(proj.path, proj.name, force, interrupt_1.signal);
+            allStats.push(stats);
+        }
+        (0, interrupt_1.teardownInterrupt)();
+        if (interrupt_1.signal.aborted)
+            console.log('\nIndexing interrupted.');
+        printSummary(allStats);
+        if (!interrupt_1.signal.aborted)
+            (0, graph_1.generateProjectGraph)(projects, workspacePath);
+        process.exit(0);
+    }
+    else if (mode === 'mcp') {
+        if (!process.env.WORKSPACE_ROOT) {
+            console.error('WORKSPACE_ROOT is required for MCP mode. Set it in ~/.config/codesearch-mcp/.env');
+            console.error('Run `rag-setup` to configure.');
+            process.exit(1);
+        }
+        await (0, db_1.initDb)();
+        await (0, mcp_1.startMCP)();
+    }
+    else if (mode === 'setup') {
+        const { runSetup } = await Promise.resolve().then(() => __importStar(require('./src/setup')));
+        await runSetup();
+    }
+    else {
+        console.log('Usage: rag-index <path> [--reindex] [--select]');
+        console.log('       rag-mcp');
+        console.log('       rag-setup');
+        process.exit(1);
+    }
+}
+main().catch(err => { console.error(err); process.exit(1); });

package/dist/src/ast.d.ts

@@ -0,0 +1,2 @@
+import type { CodeDependency } from './db';
+export declare function extractImportEdges(filePath: string, serviceName: string): Promise<Omit<CodeDependency, 'id'>[]>;

package/dist/src/ast.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImportEdges = extractImportEdges;
+const ts_morph_1 = require("ts-morph");
+// Single ts-morph Project instance for import graph extraction.
+// skipFileDependencyResolution: false is required so getModuleSpecifierSourceFile() resolves relative imports.
+const morphProject = new ts_morph_1.Project({
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: false,
+    compilerOptions: { allowJs: true, noEmit: true },
+});
+// Extract import edges from a TS/JS file using ts-morph.
+// Only resolves relative imports (external packages are skipped).
+// Removes the source file from morphProject after parsing to prevent memory accumulation.
+async function extractImportEdges(filePath, serviceName) {
+    // Only process JS/TS files; skip declaration files
+    if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath))
+        return [];
+    // Remove stale cached version before re-adding
+    const existing = morphProject.getSourceFile(filePath);
+    if (existing)
+        morphProject.removeSourceFile(existing);
+    let sourceFile;
+    try {
+        sourceFile = morphProject.addSourceFileAtPath(filePath);
+    }
+    catch {
+        return []; // file disappeared between stat and parse
+    }
+    const edges = [];
+    for (const decl of sourceFile.getImportDeclarations()) {
+        const resolved = decl.getModuleSpecifierSourceFile();
+        if (!resolved)
+            continue; // external package or unresolvable
+        const toFile = resolved.getFilePath();
+        if (toFile.includes('/node_modules/'))
+            continue; // skip package type declarations
+        const namedImports = decl.getNamedImports();
+        const defaultImport = decl.getDefaultImport();
+        const namespaceImport = decl.getNamespaceImport();
+        if (namedImports.length > 0) {
+            for (const named of namedImports) {
+                edges.push({ project: serviceName, fromFile: filePath, fromSymbol: null, toFile, toSymbol: named.getName(), depType: 'import' });
+            }
+        }
+        else if (defaultImport) {
+            edges.push({ project: serviceName, fromFile: filePath, fromSymbol: null, toFile, toSymbol: null, depType: 'import-default' });
+        }
+        else if (namespaceImport) {
+            edges.push({ project: serviceName, fromFile: filePath, fromSymbol: null, toFile, toSymbol: null, depType: 'import-namespace' });
+        }
+        else {
+            // Side-effect import: import './foo'
+            edges.push({ project: serviceName, fromFile: filePath, fromSymbol: null, toFile, toSymbol: null, depType: 'import' });
+        }
+    }
+    // Remove from memory — prevents accumulation across large workspaces
+    morphProject.removeSourceFile(sourceFile);
+    return edges;
+}

package/dist/src/config.d.ts

@@ -0,0 +1,26 @@
+export declare const config: {
+    db: {
+        host: string;
+        port: number;
+        username: string;
+        password: string;
+        database: string;
+    };
+    ollama: {
+        host: string;
+        model: string;
+    };
+    indexer: {
+        chunkSize: number;
+        chunkOverlap: number;
+        batchSize: number;
+    };
+    search: {
+        similarityThreshold: number;
+        defaultLimit: number;
+        maxLimit: number;
+        autoTranslate: boolean;
+        translateModel: string;
+    };
+    workspaceRoot: string;
+};

package/dist/src/config.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const zod_1 = require("zod");
+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 with defaults
+    OLLAMA_HOST: zod_1.z.string().url().default('http://localhost:11434'),
+    OLLAMA_MODEL: zod_1.z.string().default('bge-m3'),
+    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(),
+});
+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(', ')}`);
+    }
+    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,
+    },
+    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 ?? '',
+};

package/dist/src/db/data-source.d.ts

@@ -0,0 +1,2 @@
+import { DataSource } from 'typeorm';
+export declare const db: DataSource;

package/dist/src/db/data-source.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.db = void 0;
+const typeorm_1 = require("typeorm");
+const config_1 = require("../config");
+const code_chunk_entity_1 = require("./entities/code-chunk.entity");
+const code_dependency_entity_1 = require("./entities/code-dependency.entity");
+exports.db = new typeorm_1.DataSource({
+    type: 'postgres',
+    ...config_1.config.db,
+    entities: [code_chunk_entity_1.CodeChunk, code_dependency_entity_1.CodeDependency],
+    synchronize: false,
+});

package/dist/src/db/entities/code-chunk.entity.d.ts

@@ -0,0 +1,9 @@
+export declare class CodeChunk {
+    id: string;
+    serviceName: string;
+    filePath: string;
+    startLine: number;
+    content: string;
+    embedding: string;
+    lastModified: number;
+}

package/dist/src/db/entities/code-chunk.entity.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeChunk = void 0;
+const typeorm_1 = require("typeorm");
+let CodeChunk = class CodeChunk {
+    id;
+    serviceName;
+    filePath;
+    startLine;
+    content;
+    embedding;
+    lastModified;
+};
+exports.CodeChunk = CodeChunk;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], CodeChunk.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeChunk.prototype, "serviceName", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeChunk.prototype, "filePath", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", Number)
+], CodeChunk.prototype, "startLine", void 0);
+__decorate([
+    (0, typeorm_1.Column)('text'),
+    __metadata("design:type", String)
+], CodeChunk.prototype, "content", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'vector', length: 1024 }),
+    __metadata("design:type", String)
+], CodeChunk.prototype, "embedding", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'double precision', nullable: true }),
+    __metadata("design:type", Number)
+], CodeChunk.prototype, "lastModified", void 0);
+exports.CodeChunk = CodeChunk = __decorate([
+    (0, typeorm_1.Entity)()
+], CodeChunk);

package/dist/src/db/entities/code-dependency.entity.d.ts

@@ -0,0 +1,9 @@
+export declare class CodeDependency {
+    id: string;
+    project: string;
+    fromFile: string;
+    fromSymbol: string | null;
+    toFile: string;
+    toSymbol: string | null;
+    depType: string;
+}

package/dist/src/db/entities/code-dependency.entity.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeDependency = void 0;
+const typeorm_1 = require("typeorm");
+let CodeDependency = class CodeDependency {
+    id;
+    project;
+    fromFile;
+    fromSymbol;
+    toFile;
+    toSymbol;
+    depType; // 'import' | 'import-default' | 'import-namespace'
+};
+exports.CodeDependency = CodeDependency;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], CodeDependency.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeDependency.prototype, "project", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeDependency.prototype, "fromFile", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], CodeDependency.prototype, "fromSymbol", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeDependency.prototype, "toFile", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", Object)
+], CodeDependency.prototype, "toSymbol", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], CodeDependency.prototype, "depType", void 0);
+exports.CodeDependency = CodeDependency = __decorate([
+    (0, typeorm_1.Entity)()
+], CodeDependency);

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

@@ -0,0 +1,4 @@
+export { CodeChunk } from './entities/code-chunk.entity';
+export { CodeDependency } from './entities/code-dependency.entity';
+export { db } from './data-source';
+export { initDb, initDbWithSchema } from './init';

package/dist/src/db/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDbWithSchema = exports.initDb = exports.db = 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 data_source_1 = require("./data-source");
+Object.defineProperty(exports, "db", { enumerable: true, get: function () { return data_source_1.db; } });
+var init_1 = require("./init");
+Object.defineProperty(exports, "initDb", { enumerable: true, get: function () { return init_1.initDb; } });
+Object.defineProperty(exports, "initDbWithSchema", { enumerable: true, get: function () { return init_1.initDbWithSchema; } });

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

@@ -0,0 +1,2 @@
+export declare function initDb(): Promise<void>;
+export declare function initDbWithSchema(): Promise<void>;

package/dist/src/db/init.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDb = initDb;
+exports.initDbWithSchema = initDbWithSchema;
+const data_source_1 = require("./data-source");
+// For MCP server — just connect, no schema changes
+async function initDb() {
+    await data_source_1.db.initialize();
+}
+// For indexer — connect + create schema only if tables don't exist yet
+async function initDbWithSchema() {
+    await data_source_1.db.initialize();
+    // code_chunk table
+    const [{ exists }] = await data_source_1.db.query(`
+    SELECT EXISTS (
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name = 'code_chunk'
+    )
+  `);
+    if (!exists) {
+        await data_source_1.db.synchronize();
+        await data_source_1.db.query(`
+      CREATE INDEX idx_code_chunk_embedding
+      ON code_chunk USING hnsw (embedding vector_cosine_ops)
+    `);
+    }
+    // code_dependency table
+    const [{ existsDep }] = await data_source_1.db.query(`
+    SELECT EXISTS (
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name = 'code_dependency'
+    ) AS "existsDep"
+  `);
+    if (!existsDep) {
+        await data_source_1.db.query(`
+      CREATE TABLE code_dependency (
+        id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        project     TEXT NOT NULL,
+        "fromFile"  TEXT NOT NULL,
+        "fromSymbol" TEXT,
+        "toFile"    TEXT NOT NULL,
+        "toSymbol"  TEXT,
+        "depType"   TEXT NOT NULL
+      )
+    `);
+        await data_source_1.db.query(`CREATE INDEX idx_dep_from    ON code_dependency ("fromFile")`);
+        await data_source_1.db.query(`CREATE INDEX idx_dep_to      ON code_dependency ("toFile")`);
+        await data_source_1.db.query(`CREATE INDEX idx_dep_project ON code_dependency (project)`);
+    }
+}

package/dist/src/env-loader.d.ts

@@ -0,0 +1 @@
+export {};