@tai-io/codesearch 2026.313.1614

package/dist/hooks/cli-router.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI subcommand router for hook events.
+ *
+ * Plugin bash hooks call `npx eidetic-codesearch hook <event>` which routes here.
+ */
+export declare function runHook(event: string | undefined): Promise<void>;
+//# sourceMappingURL=cli-router.d.ts.map

package/dist/hooks/cli-router.js

@@ -0,0 +1,47 @@
+/**
+ * CLI subcommand router for hook events.
+ *
+ * Plugin bash hooks call `npx eidetic-codesearch hook <event>` which routes here.
+ */
+export async function runHook(event) {
+    switch (event) {
+        case 'stop': {
+            const { run } = await import('./stop-hook.js');
+            await run();
+            break;
+        }
+        case 'post-tool-use': {
+            const { run } = await import('./post-tool-use.js');
+            await run();
+            break;
+        }
+        case 'setup-message': {
+            const mode = process.argv[4] ?? 'welcome';
+            const detail = process.argv[5];
+            const { getSetupErrorMessage, getWelcomeMessage } = await import('../setup-message.js');
+            if (mode === 'welcome') {
+                const output = {
+                    hookSpecificOutput: {
+                        hookEventName: 'SessionStart',
+                        additionalContext: getWelcomeMessage(),
+                    },
+                };
+                process.stdout.write(JSON.stringify(output));
+            }
+            else {
+                const output = {
+                    hookSpecificOutput: {
+                        hookEventName: 'SessionStart',
+                        additionalContext: getSetupErrorMessage(detail ?? 'OPENAI_API_KEY is not set.', mode),
+                    },
+                };
+                process.stdout.write(JSON.stringify(output));
+            }
+            break;
+        }
+        default:
+            process.stderr.write(`Unknown hook event: ${event ?? '(none)'}\n`);
+            process.exit(1);
+    }
+}
+//# sourceMappingURL=cli-router.js.map

package/dist/hooks/hook-output.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Strongly typed Claude Code hook output schemas.
+ *
+ * Every hook must output JSON to stdout matching these types.
+ * See: https://docs.anthropic.com/en/docs/claude-code/hooks
+ *
+ * Base fields (available for ALL hooks):
+ *   continue, suppressOutput, stopReason, decision, reason, systemMessage
+ *
+ * hookSpecificOutput varies by event:
+ *   PreToolUse  → permissionDecision, permissionDecisionReason, updatedInput
+ *   UserPromptSubmit → additionalContext (required)
+ *   PostToolUse → additionalContext (optional)
+ *   SessionStart → additionalContext (optional)
+ *   PreCompact / SessionEnd / Stop → no hookSpecificOutput defined
+ */
+interface HookOutputBase {
+    continue?: boolean;
+    suppressOutput?: boolean;
+    stopReason?: string;
+    decision?: 'approve' | 'block';
+    reason?: string;
+    systemMessage?: string;
+}
+export interface PreToolUseOutput extends HookOutputBase {
+    hookSpecificOutput?: {
+        hookEventName: 'PreToolUse';
+        permissionDecision?: 'allow' | 'deny' | 'ask';
+        permissionDecisionReason?: string;
+        updatedInput?: Record<string, unknown>;
+    };
+}
+export interface UserPromptSubmitOutput extends HookOutputBase {
+    hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit';
+        additionalContext: string;
+    };
+}
+export interface PostToolUseOutput extends HookOutputBase {
+    hookSpecificOutput?: {
+        hookEventName: 'PostToolUse';
+        additionalContext?: string;
+    };
+}
+export interface SessionStartOutput extends HookOutputBase {
+    hookSpecificOutput?: {
+        hookEventName: 'SessionStart';
+        additionalContext?: string;
+    };
+}
+/** PreCompact, SessionEnd, Stop — no hookSpecificOutput defined. */
+export type SimpleHookOutput = HookOutputBase;
+export type HookOutput = PreToolUseOutput | UserPromptSubmitOutput | PostToolUseOutput | SessionStartOutput | SimpleHookOutput;
+export declare function writeHookOutput(output: HookOutput): void;
+export {};
+//# sourceMappingURL=hook-output.d.ts.map

package/dist/hooks/hook-output.js

@@ -0,0 +1,21 @@
+/**
+ * Strongly typed Claude Code hook output schemas.
+ *
+ * Every hook must output JSON to stdout matching these types.
+ * See: https://docs.anthropic.com/en/docs/claude-code/hooks
+ *
+ * Base fields (available for ALL hooks):
+ *   continue, suppressOutput, stopReason, decision, reason, systemMessage
+ *
+ * hookSpecificOutput varies by event:
+ *   PreToolUse  → permissionDecision, permissionDecisionReason, updatedInput
+ *   UserPromptSubmit → additionalContext (required)
+ *   PostToolUse → additionalContext (optional)
+ *   SessionStart → additionalContext (optional)
+ *   PreCompact / SessionEnd / Stop → no hookSpecificOutput defined
+ */
+// ── Helper to write output to stdout ──────────────────────────────────
+export function writeHookOutput(output) {
+    process.stdout.write(JSON.stringify(output));
+}
+//# sourceMappingURL=hook-output.js.map

package/dist/hooks/post-tool-use.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse hook entry point.
+ *
+ * Receives hook data via stdin when Write or Edit tools are used.
+ * Maintains a shadow git index per session to track which files were
+ * modified, without touching HEAD or the working index.
+ *
+ * Shadow index: <git-dir>/claude/indexes/<session-id>/index
+ * Base commit:  <git-dir>/claude/indexes/<session-id>/base_commit
+ */
+export declare function run(): Promise<void>;
+//# sourceMappingURL=post-tool-use.d.ts.map

package/dist/hooks/post-tool-use.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse hook entry point.
+ *
+ * Receives hook data via stdin when Write or Edit tools are used.
+ * Maintains a shadow git index per session to track which files were
+ * modified, without touching HEAD or the working index.
+ *
+ * Shadow index: <git-dir>/claude/indexes/<session-id>/index
+ * Base commit:  <git-dir>/claude/indexes/<session-id>/base_commit
+ */
+import { z } from 'zod';
+import path from 'node:path';
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const PostToolUseInputSchema = z.object({
+    session_id: z.string(),
+    cwd: z.string(),
+    hook_event_name: z.literal('PostToolUse'),
+    tool_name: z.string(),
+    tool_input: z
+        .object({
+        file_path: z.string().optional(),
+    })
+        .passthrough(),
+});
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+function outputSuccess() {
+    const output = {
+        hookSpecificOutput: { hookEventName: 'PostToolUse' },
+    };
+    process.stdout.write(JSON.stringify(output));
+}
+function outputError(message) {
+    process.stderr.write(`[codesearch:post-tool-use] ${message}\n`);
+    const output = {
+        hookSpecificOutput: { hookEventName: 'PostToolUse' },
+    };
+    process.stdout.write(JSON.stringify(output));
+}
+export async function run() {
+    try {
+        const input = await readStdin();
+        const parseResult = PostToolUseInputSchema.safeParse(JSON.parse(input));
+        if (!parseResult.success) {
+            outputError(`Invalid hook input: ${parseResult.error.message}`);
+            return;
+        }
+        const { session_id, cwd, tool_name, tool_input } = parseResult.data;
+        // Safety check beyond matcher — only process Write and Edit
+        if (tool_name !== 'Write' && tool_name !== 'Edit') {
+            outputSuccess();
+            return;
+        }
+        const filePath = tool_input.file_path;
+        if (!filePath) {
+            outputSuccess();
+            return;
+        }
+        // Resolve git dir
+        let gitDir;
+        try {
+            gitDir = execFileSync('git', ['-C', cwd, 'rev-parse', '--git-dir'], {
+                encoding: 'utf-8',
+                timeout: 5000,
+            }).trim();
+        }
+        catch {
+            // Not a git repo — silently skip
+            outputSuccess();
+            return;
+        }
+        if (!path.isAbsolute(gitDir)) {
+            gitDir = path.resolve(cwd, gitDir);
+        }
+        const shadowDir = path.join(gitDir, 'claude', 'indexes', session_id);
+        const shadowIndex = path.join(shadowDir, 'index');
+        const baseCommitFile = path.join(shadowDir, 'base_commit');
+        // First call for this session: seed shadow index from HEAD
+        if (!fs.existsSync(shadowIndex)) {
+            fs.mkdirSync(shadowDir, { recursive: true });
+            let headSha;
+            try {
+                headSha = execFileSync('git', ['-C', cwd, 'rev-parse', 'HEAD'], {
+                    encoding: 'utf-8',
+                    timeout: 5000,
+                }).trim();
+            }
+            catch {
+                // Empty repo / no commits — cannot seed from HEAD
+                outputSuccess();
+                return;
+            }
+            // Seed shadow index from HEAD tree
+            execFileSync('git', ['-C', cwd, 'read-tree', `--index-output=${shadowIndex}`, 'HEAD'], {
+                timeout: 5000,
+            });
+            fs.writeFileSync(baseCommitFile, headSha, 'utf-8');
+        }
+        // Stage the file into the shadow index
+        const absoluteFilePath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+        execFileSync('git', ['-C', cwd, 'add', absoluteFilePath], {
+            env: { ...process.env, GIT_INDEX_FILE: shadowIndex },
+            timeout: 5000,
+        });
+        outputSuccess();
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+    }
+}
+// CLI router calls run() directly; self-execute when run as standalone script
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    void run();
+}
+//# sourceMappingURL=post-tool-use.js.map

package/dist/hooks/stop-hook.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Stop hook entry point.
+ *
+ * Receives hook data via stdin when a Claude session ends.
+ * Commits the session's shadow git index to refs/heads/claude/<session-id>,
+ * diffs against base commit to find modified files, then spawns a
+ * detached background targeted re-indexer.
+ */
+export declare function run(): Promise<void>;
+//# sourceMappingURL=stop-hook.d.ts.map

package/dist/hooks/stop-hook.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * Stop hook entry point.
+ *
+ * Receives hook data via stdin when a Claude session ends.
+ * Commits the session's shadow git index to refs/heads/claude/<session-id>,
+ * diffs against base commit to find modified files, then spawns a
+ * detached background targeted re-indexer.
+ */
+import { z } from 'zod';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { execFileSync, spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const StopInputSchema = z.object({
+    session_id: z.string(),
+    cwd: z.string(),
+    hook_event_name: z.literal('Stop'),
+    stop_hook_active: z.boolean().optional(),
+});
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+function outputSuccess() {
+    const output = {};
+    process.stdout.write(JSON.stringify(output));
+}
+function outputError(message) {
+    process.stderr.write(`[codesearch:stop-hook] ${message}\n`);
+    const output = {};
+    process.stdout.write(JSON.stringify(output));
+}
+export async function run() {
+    try {
+        const input = await readStdin();
+        const parseResult = StopInputSchema.safeParse(JSON.parse(input));
+        if (!parseResult.success) {
+            outputError(`Invalid hook input: ${parseResult.error.message}`);
+            return;
+        }
+        const { session_id, cwd } = parseResult.data;
+        // Resolve git dir
+        let gitDir;
+        try {
+            gitDir = execFileSync('git', ['-C', cwd, 'rev-parse', '--git-dir'], {
+                encoding: 'utf-8',
+                timeout: 5000,
+            }).trim();
+        }
+        catch {
+            // Not a git repo — nothing to do
+            outputSuccess();
+            return;
+        }
+        if (!path.isAbsolute(gitDir)) {
+            gitDir = path.resolve(cwd, gitDir);
+        }
+        const shadowDir = path.join(gitDir, 'claude', 'indexes', session_id);
+        const shadowIndex = path.join(shadowDir, 'index');
+        const baseCommitFile = path.join(shadowDir, 'base_commit');
+        // No shadow index means no edits happened this session
+        if (!fs.existsSync(shadowIndex)) {
+            outputSuccess();
+            return;
+        }
+        if (!fs.existsSync(baseCommitFile)) {
+            // Missing base commit file — clean up and bail
+            try {
+                fs.rmSync(shadowDir, { recursive: true, force: true });
+            }
+            catch {
+                // Cleanup is best-effort
+            }
+            outputSuccess();
+            return;
+        }
+        const baseCommit = fs.readFileSync(baseCommitFile, 'utf-8').trim();
+        // Write tree from shadow index
+        const treeSha = execFileSync('git', ['-C', cwd, 'write-tree'], {
+            env: { ...process.env, GIT_INDEX_FILE: shadowIndex },
+            encoding: 'utf-8',
+            timeout: 10000,
+        }).trim();
+        // Create a commit object pointing to that tree
+        const commitSha = execFileSync('git', ['-C', cwd, 'commit-tree', treeSha, '-p', baseCommit, '-m', `codesearch: session ${session_id}`], { encoding: 'utf-8', timeout: 10000 }).trim();
+        // Store under refs/heads/claude/<session-id> for history
+        execFileSync('git', ['-C', cwd, 'update-ref', `refs/heads/claude/${session_id}`, commitSha], {
+            timeout: 5000,
+        });
+        // Find files that changed between base and new commit
+        const diffOutput = execFileSync('git', ['-C', cwd, 'diff-tree', '--no-commit-id', '--name-only', '-r', baseCommit, commitSha], { encoding: 'utf-8', timeout: 5000 }).trim();
+        const modifiedFiles = diffOutput
+            .split('\n')
+            .map((f) => f.trim())
+            .filter((f) => f.length > 0);
+        // Clean up shadow index directory
+        try {
+            fs.rmSync(shadowDir, { recursive: true, force: true });
+        }
+        catch (err) {
+            process.stderr.write(`[codesearch:stop-hook] Failed to clean shadow index: ${String(err)}\n`);
+        }
+        if (modifiedFiles.length === 0) {
+            outputSuccess();
+            return;
+        }
+        // Write manifest for targeted runner
+        const manifest = { projectPath: cwd, modifiedFiles };
+        const manifestFile = path.join(os.tmpdir(), `codesearch-reindex-${session_id}.json`);
+        fs.writeFileSync(manifestFile, JSON.stringify(manifest), 'utf-8');
+        // Spawn detached background targeted runner
+        const runnerPath = path.join(__dirname, 'targeted-runner.js');
+        const child = spawn(process.execPath, [runnerPath, manifestFile], {
+            detached: true,
+            stdio: 'ignore',
+            env: process.env,
+            windowsHide: true,
+        });
+        child.unref();
+        outputSuccess();
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+    }
+}
+// CLI router calls run() directly; self-execute when run as standalone script
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    void run();
+}
+//# sourceMappingURL=stop-hook.js.map

package/dist/hooks/targeted-runner.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Standalone CLI for background targeted re-indexing.
+ * Spawned as a detached child process by stop-hook.ts.
+ *
+ * Usage: node targeted-runner.js <manifest-json-path>
+ *
+ * Manifest JSON: { projectPath: string, modifiedFiles: string[] }
+ */
+export {};
+//# sourceMappingURL=targeted-runner.d.ts.map

package/dist/hooks/targeted-runner.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * Standalone CLI for background targeted re-indexing.
+ * Spawned as a detached child process by stop-hook.ts.
+ *
+ * Usage: node targeted-runner.js <manifest-json-path>
+ *
+ * Manifest JSON: { projectPath: string, modifiedFiles: string[] }
+ */
+import fs from 'node:fs';
+import { indexFiles } from '../core/targeted-indexer.js';
+import { createEmbedding } from '../embedding/factory.js';
+import { SqliteVectorDB } from '../vectordb/sqlite.js';
+import { getCodesearchDbPath } from '../paths.js';
+import { loadConfig } from '../config.js';
+async function main() {
+    const manifestPath = process.argv[2];
+    if (!manifestPath) {
+        process.stderr.write('Usage: targeted-runner.js <manifest-json-path>\n');
+        process.exit(1);
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    }
+    catch (err) {
+        process.stderr.write(`[targeted-runner] Failed to read manifest: ${String(err)}\n`);
+        process.exit(1);
+    }
+    // Clean up manifest file
+    try {
+        fs.unlinkSync(manifestPath);
+    }
+    catch {
+        // Ignore — best effort
+    }
+    const { projectPath, modifiedFiles } = manifest;
+    if (!projectPath || !Array.isArray(modifiedFiles) || modifiedFiles.length === 0) {
+        process.stderr.write('[targeted-runner] Empty or invalid manifest, nothing to do.\n');
+        process.exit(0);
+    }
+    try {
+        const config = loadConfig();
+        const embedding = createEmbedding(config);
+        await embedding.initialize();
+        const vectordb = new SqliteVectorDB(getCodesearchDbPath());
+        const result = await indexFiles(projectPath, modifiedFiles, embedding, vectordb);
+        process.stderr.write(`[targeted-runner] Re-indexed ${result.processedFiles} files ` +
+            `(${result.totalChunks} chunks, ${result.skippedFiles} deleted) ` +
+            `in ${result.durationMs}ms\n`);
+    }
+    catch (err) {
+        process.stderr.write(`[targeted-runner] Failed: ${String(err)}\n`);
+        process.exit(1);
+    }
+}
+void main();
+//# sourceMappingURL=targeted-runner.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+// CRITICAL: Redirect console outputs to stderr BEFORE any imports
+// Only MCP protocol messages should go to stdout
+console.log = (...args) => {
+    process.stderr.write('[LOG] ' + args.join(' ') + '\n');
+};
+console.warn = (...args) => {
+    process.stderr.write('[WARN] ' + args.join(' ') + '\n');
+};
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { loadConfig } from './config.js';
+import { createEmbedding } from './embedding/factory.js';
+import { SqliteVectorDB } from './vectordb/sqlite.js';
+import { getCodesearchDbPath } from './paths.js';
+import { StateManager, cleanupOrphanedSnapshots } from './state/snapshot.js';
+import { listProjects } from './state/registry.js';
+import { ToolHandlers } from './tools.js';
+import { TOOL_DEFINITIONS } from './tool-schemas.js';
+import { getSetupErrorMessage } from './setup-message.js';
+import { BUILD_VERSION, BUILD_TIMESTAMP } from './build-info.js';
+const SERVER_INSTRUCTIONS = `# Eidetic Codesearch — Workflow
+
+**Before searching:** Ensure the codebase is indexed.
+- \`list\` → see what's already indexed
+- \`index(path="...", dryRun=true)\` → preview before indexing
+- \`index(path="...")\` → index (incremental, only re-embeds changed files)
+
+**Searching efficiently:**
+- \`search(query="...")\` → returns compact table by default (~20 tokens/result)
+- Review the table, then use Read tool to fetch full code for interesting results
+- Add \`compact=false\` only when you need all code snippets immediately
+- Use \`extensionFilter\` to narrow by file type
+- Use \`project\` param instead of \`path\` for convenience
+- Start with specific queries, broaden if no results
+
+**After first index:**
+- Re-indexing is incremental (only changed files re-embedded)
+- Use \`project\` param instead of \`path\` for convenience
+- Use \`cleanup(path="...", dryRun=true)\` to preview stale vectors
+
+**Documentation caching (saves ~5K tokens per repeated doc fetch):**
+- After fetching docs via query-docs or WebFetch, cache them: \`ingest(content="...", source="<url>", library="<name>", topic="<topic>")\`
+- Next time you need the same docs: \`lookup(query="...", library="<name>")\`
+- Stale docs (past TTL) still return results but are flagged \`[STALE]\``;
+async function main() {
+    // CLI subcommand routing — hooks call `npx eidetic-codesearch hook <event>`
+    if (process.argv[2] === 'hook') {
+        const { runHook } = await import('./hooks/cli-router.js');
+        await runHook(process.argv[3]);
+        process.exit(0);
+    }
+    const config = loadConfig();
+    console.log(`Config loaded. Model: ${config.embeddingModel}`);
+    let handlers = null;
+    let setupError = null;
+    try {
+        const embedding = createEmbedding(config);
+        await embedding.initialize();
+        const vectordb = new SqliteVectorDB(getCodesearchDbPath());
+        console.log('Using SQLite vector database.');
+        const cleaned = await cleanupOrphanedSnapshots(vectordb);
+        if (cleaned > 0) {
+            console.log(`Cleaned ${cleaned} orphaned snapshot(s).`);
+        }
+        const state = new StateManager();
+        const hydrated = await state.hydrate(listProjects(), vectordb);
+        if (hydrated > 0) {
+            console.log(`Hydrated ${hydrated} project(s) from registry.`);
+        }
+        handlers = new ToolHandlers(embedding, vectordb, state);
+    }
+    catch (err) {
+        setupError = err instanceof Error ? err.message : String(err);
+        console.warn(`Codesearch initialization failed: ${setupError}`);
+        console.warn('Server will start in setup-required mode. All tool calls will return setup instructions.');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    const server = new Server({ name: '@tai-io/codesearch', version: BUILD_VERSION }, { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS });
+    // eslint-disable-next-line @typescript-eslint/require-await
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [...TOOL_DEFINITIONS],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        if (!handlers) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: getSetupErrorMessage(setupError ?? 'Unknown error'),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        switch (name) {
+            case 'index':
+                return handlers.handleIndex(args ?? {});
+            case 'search':
+                return handlers.handleSearch(args ?? {});
+            case 'clear':
+                return handlers.handleClear(args ?? {});
+            case 'list':
+                return handlers.handleList();
+            case 'ingest':
+                return handlers.handleIngest(args ?? {});
+            case 'lookup':
+                return handlers.handleLookup(args ?? {});
+            case 'cleanup':
+                return handlers.handleCleanup(args ?? {});
+            case 'browse':
+                return handlers.handleBrowse(args ?? {});
+            default:
+                return {
+                    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.log(`Eidetic Codesearch MCP server v${BUILD_VERSION} (built ${BUILD_TIMESTAMP}) started on stdio.`);
+}
+process.on('SIGINT', () => {
+    console.error('Received SIGINT, shutting down...');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    console.error('Received SIGTERM, shutting down...');
+    process.exit(0);
+});
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/paths.d.ts

@@ -0,0 +1,11 @@
+export declare function normalizePath(inputPath: string): string;
+export declare function getDataDir(): string;
+export declare function getSnapshotDir(): string;
+export declare function getCacheDir(): string;
+export declare function getRegistryPath(): string;
+export declare function pathToCollectionName(absolutePath: string): string;
+export declare function getCodesearchDbPath(): string;
+export declare function getSnapshotDbPath(): string;
+export declare function getDocMetadataPath(): string;
+export declare function docCollectionName(library: string): string;
+//# sourceMappingURL=paths.d.ts.map