claude-eidetic 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+declare const configSchema: z.ZodEffects<z.ZodObject<{
+    embeddingProvider: z.ZodDefault<z.ZodEnum<["openai", "ollama", "local"]>>;
+    openaiApiKey: z.ZodDefault<z.ZodString>;
+    openaiBaseUrl: z.ZodOptional<z.ZodString>;
+    ollamaBaseUrl: z.ZodDefault<z.ZodString>;
+    embeddingModel: z.ZodOptional<z.ZodString>;
+    embeddingBatchSize: z.ZodDefault<z.ZodNumber>;
+    indexingConcurrency: z.ZodDefault<z.ZodNumber>;
+    qdrantUrl: z.ZodDefault<z.ZodString>;
+    qdrantApiKey: z.ZodOptional<z.ZodString>;
+    vectordbProvider: z.ZodDefault<z.ZodEnum<["qdrant", "milvus"]>>;
+    milvusAddress: z.ZodDefault<z.ZodString>;
+    milvusToken: z.ZodOptional<z.ZodString>;
+    eideticDataDir: z.ZodDefault<z.ZodString>;
+    customExtensions: z.ZodEffects<z.ZodDefault<z.ZodArray<z.ZodString, "many">>, string[], unknown>;
+    customIgnorePatterns: z.ZodEffects<z.ZodDefault<z.ZodArray<z.ZodString, "many">>, string[], unknown>;
+}, "strip", z.ZodTypeAny, {
+    embeddingProvider: "openai" | "ollama" | "local";
+    openaiApiKey: string;
+    ollamaBaseUrl: string;
+    embeddingBatchSize: number;
+    indexingConcurrency: number;
+    qdrantUrl: string;
+    vectordbProvider: "qdrant" | "milvus";
+    milvusAddress: string;
+    eideticDataDir: string;
+    customExtensions: string[];
+    customIgnorePatterns: string[];
+    openaiBaseUrl?: string | undefined;
+    embeddingModel?: string | undefined;
+    qdrantApiKey?: string | undefined;
+    milvusToken?: string | undefined;
+}, {
+    embeddingProvider?: "openai" | "ollama" | "local" | undefined;
+    openaiApiKey?: string | undefined;
+    openaiBaseUrl?: string | undefined;
+    ollamaBaseUrl?: string | undefined;
+    embeddingModel?: string | undefined;
+    embeddingBatchSize?: number | undefined;
+    indexingConcurrency?: number | undefined;
+    qdrantUrl?: string | undefined;
+    qdrantApiKey?: string | undefined;
+    vectordbProvider?: "qdrant" | "milvus" | undefined;
+    milvusAddress?: string | undefined;
+    milvusToken?: string | undefined;
+    eideticDataDir?: string | undefined;
+    customExtensions?: unknown;
+    customIgnorePatterns?: unknown;
+}>, {
+    embeddingModel: string;
+    embeddingProvider: "openai" | "ollama" | "local";
+    openaiApiKey: string;
+    ollamaBaseUrl: string;
+    embeddingBatchSize: number;
+    indexingConcurrency: number;
+    qdrantUrl: string;
+    vectordbProvider: "qdrant" | "milvus";
+    milvusAddress: string;
+    eideticDataDir: string;
+    customExtensions: string[];
+    customIgnorePatterns: string[];
+    openaiBaseUrl?: string | undefined;
+    qdrantApiKey?: string | undefined;
+    milvusToken?: string | undefined;
+}, {
+    embeddingProvider?: "openai" | "ollama" | "local" | undefined;
+    openaiApiKey?: string | undefined;
+    openaiBaseUrl?: string | undefined;
+    ollamaBaseUrl?: string | undefined;
+    embeddingModel?: string | undefined;
+    embeddingBatchSize?: number | undefined;
+    indexingConcurrency?: number | undefined;
+    qdrantUrl?: string | undefined;
+    qdrantApiKey?: string | undefined;
+    vectordbProvider?: "qdrant" | "milvus" | undefined;
+    milvusAddress?: string | undefined;
+    milvusToken?: string | undefined;
+    eideticDataDir?: string | undefined;
+    customExtensions?: unknown;
+    customIgnorePatterns?: unknown;
+}>;
+export type Config = z.infer<typeof configSchema>;
+export declare function loadConfig(): Config;
+export declare function getConfig(): Config;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,65 @@
+import os from 'node:os';
+import path from 'node:path';
+import { z } from 'zod';
+import { ConfigError } from './errors.js';
+const configSchema = z.object({
+    embeddingProvider: z.enum(['openai', 'ollama', 'local']).default('openai'),
+    openaiApiKey: z.string().default(''),
+    openaiBaseUrl: z.string().optional(),
+    ollamaBaseUrl: z.string().default('http://localhost:11434/v1'),
+    embeddingModel: z.string().optional(),
+    embeddingBatchSize: z.coerce.number().int().min(1).max(2048).default(100),
+    indexingConcurrency: z.coerce.number().int().min(1).max(32).default(8),
+    qdrantUrl: z.string().default('http://localhost:6333'),
+    qdrantApiKey: z.string().optional(),
+    vectordbProvider: z.enum(['qdrant', 'milvus']).default('qdrant'),
+    milvusAddress: z.string().default('localhost:19530'),
+    milvusToken: z.string().optional(),
+    eideticDataDir: z.string().default(path.join(os.homedir(), '.eidetic')),
+    customExtensions: z.preprocess((val) => typeof val === 'string' ? JSON.parse(val) : val, z.array(z.string()).default([])),
+    customIgnorePatterns: z.preprocess((val) => typeof val === 'string' ? JSON.parse(val) : val, z.array(z.string()).default([])),
+}).transform((cfg) => ({
+    ...cfg,
+    // Default embedding model depends on provider
+    embeddingModel: cfg.embeddingModel
+        ?? (cfg.embeddingProvider === 'ollama' ? 'nomic-embed-text' : 'text-embedding-3-small'),
+}));
+let cachedConfig = null;
+export function loadConfig() {
+    const raw = {
+        embeddingProvider: process.env.EMBEDDING_PROVIDER,
+        openaiApiKey: process.env.OPENAI_API_KEY ?? '',
+        openaiBaseUrl: process.env.OPENAI_BASE_URL || undefined,
+        ollamaBaseUrl: process.env.OLLAMA_BASE_URL,
+        embeddingModel: process.env.EMBEDDING_MODEL || undefined,
+        embeddingBatchSize: process.env.EMBEDDING_BATCH_SIZE,
+        indexingConcurrency: process.env.INDEXING_CONCURRENCY,
+        qdrantUrl: process.env.QDRANT_URL,
+        qdrantApiKey: process.env.QDRANT_API_KEY || undefined,
+        vectordbProvider: process.env.VECTORDB_PROVIDER,
+        milvusAddress: process.env.MILVUS_ADDRESS,
+        milvusToken: process.env.MILVUS_TOKEN || undefined,
+        eideticDataDir: process.env.EIDETIC_DATA_DIR,
+        customExtensions: process.env.CUSTOM_EXTENSIONS,
+        customIgnorePatterns: process.env.CUSTOM_IGNORE_PATTERNS,
+    };
+    const result = configSchema.safeParse(raw);
+    if (!result.success) {
+        const issues = result.error.issues.map(i => `  ${i.path.join('.')}: ${i.message}`).join('\n');
+        throw new ConfigError(`Invalid configuration:\n${issues}`);
+    }
+    const config = result.data;
+    if (config.embeddingProvider === 'openai' && !config.openaiApiKey) {
+        throw new ConfigError('OPENAI_API_KEY is required when EMBEDDING_PROVIDER is "openai" (the default). ' +
+            'Set EMBEDDING_PROVIDER=ollama or EMBEDDING_PROVIDER=local to use a local embedding server.');
+    }
+    cachedConfig = config;
+    return cachedConfig;
+}
+export function getConfig() {
+    if (!cachedConfig) {
+        return loadConfig();
+    }
+    return cachedConfig;
+}
+//# sourceMappingURL=config.js.map

package/dist/core/indexer.d.ts

@@ -0,0 +1,18 @@
+import type { Embedding } from '../embedding/types.js';
+import type { VectorDB } from '../vectordb/types.js';
+export { previewCodebase, type PreviewResult } from './preview.js';
+export { saveSnapshot, deleteSnapshot, snapshotExists } from './snapshot-io.js';
+export interface IndexResult {
+    totalFiles: number;
+    totalChunks: number;
+    addedFiles: number;
+    modifiedFiles: number;
+    removedFiles: number;
+    skippedFiles: number;
+    estimatedTokens: number;
+    estimatedCostUsd: number;
+    durationMs: number;
+    parseFailures: string[];
+}
+export declare function indexCodebase(rootPath: string, embedding: Embedding, vectordb: VectorDB, force?: boolean, onProgress?: (pct: number, msg: string) => void, customExtensions?: string[], customIgnorePatterns?: string[]): Promise<IndexResult>;
+//# sourceMappingURL=indexer.d.ts.map

package/dist/core/indexer.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { AstSplitter } from '../splitter/ast.js';
+import { LineSplitter } from '../splitter/line.js';
+import { scanFiles, buildSnapshot, diffSnapshots, extensionToLanguage } from './sync.js';
+import { getConfig } from '../config.js';
+import { normalizePath, pathToCollectionName } from '../paths.js';
+import { IndexingError } from '../errors.js';
+import { loadSnapshot, saveSnapshot } from './snapshot-io.js';
+export { previewCodebase } from './preview.js';
+export { saveSnapshot, deleteSnapshot, snapshotExists } from './snapshot-io.js';
+export async function indexCodebase(rootPath, embedding, vectordb, force = false, onProgress, customExtensions, customIgnorePatterns) {
+    const start = Date.now();
+    const normalizedPath = normalizePath(rootPath);
+    const collectionName = pathToCollectionName(normalizedPath);
+    const config = getConfig();
+    onProgress?.(0, 'Scanning files...');
+    const filePaths = await scanFiles(normalizedPath, customExtensions, customIgnorePatterns);
+    if (filePaths.length === 0) {
+        throw new IndexingError(`No indexable files found in ${normalizedPath}`);
+    }
+    const currentSnapshot = buildSnapshot(normalizedPath, filePaths);
+    let filesToProcess;
+    let removedFiles = [];
+    let addedCount = 0;
+    let modifiedCount = 0;
+    if (force) {
+        onProgress?.(5, 'Dropping existing index...');
+        await vectordb.dropCollection(collectionName);
+        await vectordb.createCollection(collectionName, embedding.dimension);
+        filesToProcess = filePaths;
+        addedCount = filePaths.length;
+    }
+    else {
+        const previousSnapshot = loadSnapshot(normalizedPath);
+        if (!previousSnapshot || !(await vectordb.hasCollection(collectionName))) {
+            // First time indexing
+            await vectordb.createCollection(collectionName, embedding.dimension);
+            filesToProcess = filePaths;
+            addedCount = filePaths.length;
+        }
+        else {
+            const diff = diffSnapshots(previousSnapshot, currentSnapshot);
+            addedCount = diff.added.length;
+            modifiedCount = diff.modified.length;
+            removedFiles = diff.removed;
+            const toDelete = [...diff.removed, ...diff.modified];
+            for (const rel of toDelete) {
+                await vectordb.deleteByPath(collectionName, rel);
+            }
+            filesToProcess = [...diff.added, ...diff.modified];
+        }
+    }
+    if (filesToProcess.length === 0) {
+        saveSnapshot(normalizedPath, currentSnapshot);
+        return {
+            totalFiles: filePaths.length,
+            totalChunks: 0,
+            addedFiles: 0,
+            modifiedFiles: 0,
+            removedFiles: removedFiles.length,
+            skippedFiles: filePaths.length,
+            estimatedTokens: 0,
+            estimatedCostUsd: 0,
+            durationMs: Date.now() - start,
+            parseFailures: [],
+        };
+    }
+    onProgress?.(10, `Splitting ${filesToProcess.length} files...`);
+    const astSplitter = new AstSplitter();
+    const lineSplitter = new LineSplitter();
+    const allChunks = [];
+    const parseFailures = [];
+    const concurrency = config.indexingConcurrency;
+    for (let i = 0; i < filesToProcess.length; i += concurrency) {
+        const batch = filesToProcess.slice(i, i + concurrency);
+        const batchResults = await Promise.all(batch.map(async (relPath) => {
+            const fullPath = path.join(normalizedPath, relPath);
+            try {
+                const code = fs.readFileSync(fullPath, 'utf-8');
+                if (code.trim().length === 0)
+                    return { chunks: [], failed: false };
+                const ext = path.extname(relPath);
+                const language = extensionToLanguage(ext);
+                let chunks = astSplitter.split(code, language, relPath);
+                if (chunks.length === 0) {
+                    chunks = lineSplitter.split(code, language, relPath);
+                }
+                if (chunks.length === 0)
+                    return { chunks: [], failed: true };
+                return { chunks, failed: false };
+            }
+            catch (err) {
+                console.warn(`Failed to process "${relPath}": ${err}`);
+                return { chunks: [], failed: true };
+            }
+        }));
+        for (let j = 0; j < batchResults.length; j++) {
+            const { chunks, failed } = batchResults[j];
+            allChunks.push(...chunks);
+            if (failed)
+                parseFailures.push(batch[j]);
+        }
+    }
+    if (parseFailures.length > 0) {
+        console.warn(`Warning: ${parseFailures.length} file(s) produced no chunks: ${parseFailures.slice(0, 10).join(', ')}` +
+            (parseFailures.length > 10 ? ` (and ${parseFailures.length - 10} more)` : ''));
+    }
+    if (allChunks.length === 0) {
+        saveSnapshot(normalizedPath, currentSnapshot);
+        return {
+            totalFiles: filePaths.length,
+            totalChunks: 0,
+            addedFiles: addedCount,
+            modifiedFiles: modifiedCount,
+            removedFiles: removedFiles.length,
+            skippedFiles: filePaths.length - filesToProcess.length,
+            estimatedTokens: 0,
+            estimatedCostUsd: 0,
+            durationMs: Date.now() - start,
+            parseFailures,
+        };
+    }
+    const chunkTexts = allChunks.map(c => c.content);
+    const estimation = embedding.estimateTokens(chunkTexts);
+    console.log(`Indexing ${filesToProcess.length} files -> ${allChunks.length} chunks -> ` +
+        `~${(estimation.estimatedTokens / 1000).toFixed(0)}K tokens (~$${estimation.estimatedCostUsd.toFixed(4)})`);
+    const batchSize = config.embeddingBatchSize;
+    let processedChunks = 0;
+    for (let i = 0; i < allChunks.length; i += batchSize) {
+        const batch = allChunks.slice(i, i + batchSize);
+        const texts = batch.map(c => c.content);
+        const pct = 10 + Math.round((i / allChunks.length) * 85);
+        onProgress?.(pct, `Embedding batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(allChunks.length / batchSize)}...`);
+        const vectors = await embedding.embedBatch(texts);
+        if (vectors.length !== texts.length) {
+            throw new IndexingError(`Embedding dimension mismatch: sent ${texts.length} texts, got ${vectors.length} vectors`);
+        }
+        const documents = batch.map((chunk, j) => ({
+            id: randomUUID(),
+            content: chunk.content,
+            vector: vectors[j],
+            relativePath: chunk.filePath,
+            startLine: chunk.startLine,
+            endLine: chunk.endLine,
+            fileExtension: path.extname(chunk.filePath),
+            language: chunk.language,
+        }));
+        await vectordb.insert(collectionName, documents);
+        processedChunks += batch.length;
+    }
+    onProgress?.(98, 'Saving snapshot...');
+    saveSnapshot(normalizedPath, currentSnapshot);
+    onProgress?.(100, 'Done');
+    return {
+        totalFiles: filePaths.length,
+        totalChunks: processedChunks,
+        addedFiles: addedCount,
+        modifiedFiles: modifiedCount,
+        removedFiles: removedFiles.length,
+        skippedFiles: filePaths.length - filesToProcess.length,
+        estimatedTokens: estimation.estimatedTokens,
+        estimatedCostUsd: estimation.estimatedCostUsd,
+        durationMs: Date.now() - start,
+        parseFailures,
+    };
+}
+//# sourceMappingURL=indexer.js.map

package/dist/core/preview.d.ts

@@ -0,0 +1,14 @@
+import type { Embedding } from '../embedding/types.js';
+export interface PreviewResult {
+    totalFiles: number;
+    byExtension: Record<string, number>;
+    topDirectories: {
+        dir: string;
+        count: number;
+    }[];
+    estimatedTokens: number;
+    estimatedCostUsd: number;
+    warnings: string[];
+}
+export declare function previewCodebase(rootPath: string, embedding: Embedding, customExtensions?: string[], customIgnorePatterns?: string[]): Promise<PreviewResult>;
+//# sourceMappingURL=preview.d.ts.map

package/dist/core/preview.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { scanFiles } from './sync.js';
+import { normalizePath } from '../paths.js';
+export async function previewCodebase(rootPath, embedding, customExtensions, customIgnorePatterns) {
+    const normalizedPath = normalizePath(rootPath);
+    const filePaths = await scanFiles(normalizedPath, customExtensions, customIgnorePatterns);
+    const byExtension = {};
+    for (const f of filePaths) {
+        const ext = path.extname(f).toLowerCase() || '(no ext)';
+        byExtension[ext] = (byExtension[ext] ?? 0) + 1;
+    }
+    const dirCounts = {};
+    for (const f of filePaths) {
+        const firstSeg = f.split(/[/\\]/)[0];
+        const dir = f.includes('/') || f.includes('\\') ? firstSeg : '(root)';
+        dirCounts[dir] = (dirCounts[dir] ?? 0) + 1;
+    }
+    const topDirectories = Object.entries(dirCounts)
+        .map(([dir, count]) => ({ dir, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 10);
+    // Estimate tokens from file sizes (rough: sum sizes / 4 chars-per-token)
+    let totalBytes = 0;
+    for (const f of filePaths) {
+        try {
+            const stat = fs.statSync(path.join(normalizedPath, f));
+            totalBytes += stat.size;
+        }
+        catch {
+            // File may have disappeared between scan and stat
+        }
+    }
+    // Conservative estimate: ~3-4 chars per token for code.
+    // May underestimate for dense code; will be refined during actual indexing.
+    const estimatedTokens = Math.ceil(totalBytes / 3);
+    const estimatedCostUsd = (estimatedTokens / 1_000_000) * 0.02;
+    const warnings = [];
+    if (filePaths.length === 0) {
+        warnings.push('No indexable files found. Check file extension filters and ignore patterns.');
+    }
+    if (filePaths.length > 5000) {
+        warnings.push(`Found ${filePaths.length.toLocaleString()} files. Most codebases have 100-5,000 source files. Consider adding ignore patterns.`);
+    }
+    if (topDirectories.length > 0 && filePaths.length > 0) {
+        const topDir = topDirectories[0];
+        const pct = Math.round((topDir.count / filePaths.length) * 100);
+        if (pct > 50 && topDir.dir !== '(root)') {
+            warnings.push(`Directory '${topDir.dir}/' contains ${pct}% of files -- consider ignoring if it contains build artifacts or dependencies.`);
+        }
+    }
+    return {
+        totalFiles: filePaths.length,
+        byExtension,
+        topDirectories,
+        estimatedTokens,
+        estimatedCostUsd,
+        warnings,
+    };
+}
+//# sourceMappingURL=preview.js.map

package/dist/core/searcher.d.ts

@@ -0,0 +1,24 @@
+import type { Embedding } from '../embedding/types.js';
+import type { VectorDB, SearchResult } from '../vectordb/types.js';
+export interface SearchOptions {
+    limit?: number;
+    extensionFilter?: string[];
+}
+export declare function searchCode(rootPath: string, query: string, embedding: Embedding, vectordb: VectorDB, options?: SearchOptions): Promise<SearchResult[]>;
+/**
+ * Deduplicate overlapping chunks from the same file.
+ * Results are already sorted by score (best first). For each file, keep only
+ * chunks whose line ranges do not overlap with an already-accepted chunk.
+ */
+export declare function deduplicateResults(results: SearchResult[], limit: number): SearchResult[];
+/**
+ * Format search results as a compact markdown table for token-efficient output.
+ * Returns file paths, line ranges, scores, and estimated token costs.
+ * Consumers use the Read tool to fetch full code for interesting results.
+ */
+export declare function formatCompactResults(results: SearchResult[], query: string, rootPath: string): string;
+/**
+ * Format search results as markdown for MCP tool output.
+ */
+export declare function formatSearchResults(results: SearchResult[], query: string, rootPath: string): string;
+//# sourceMappingURL=searcher.d.ts.map

package/dist/core/searcher.js

@@ -0,0 +1,101 @@
+import { normalizePath, pathToCollectionName } from '../paths.js';
+import { SearchError } from '../errors.js';
+const DEFAULT_LIMIT = 10;
+const MAX_LIMIT = 50;
+export async function searchCode(rootPath, query, embedding, vectordb, options = {}) {
+    const normalizedPath = normalizePath(rootPath);
+    const collectionName = pathToCollectionName(normalizedPath);
+    // Check collection exists
+    const exists = await vectordb.hasCollection(collectionName);
+    if (!exists) {
+        throw new SearchError(`Codebase at "${normalizedPath}" is not indexed. ` +
+            `Use the index_codebase tool to index it first.`);
+    }
+    const limit = Math.min(Math.max(1, options.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
+    // Embed the query
+    const queryVector = await embedding.embed(query);
+    // Overfetch to allow dedup to still return enough results
+    const overFetchLimit = Math.min(limit * 3, MAX_LIMIT);
+    // Hybrid search (dense + full-text + RRF with exponential decay)
+    const results = await vectordb.search(collectionName, {
+        queryVector,
+        queryText: query,
+        limit: overFetchLimit,
+        extensionFilter: options.extensionFilter,
+    });
+    // Deduplicate overlapping chunks from the same file (keep highest-scored)
+    return deduplicateResults(results, limit);
+}
+/**
+ * Deduplicate overlapping chunks from the same file.
+ * Results are already sorted by score (best first). For each file, keep only
+ * chunks whose line ranges do not overlap with an already-accepted chunk.
+ */
+export function deduplicateResults(results, limit) {
+    const accepted = [];
+    // Track accepted line ranges per file: relativePath -> [startLine, endLine][]
+    const fileRanges = new Map();
+    for (const r of results) {
+        if (accepted.length >= limit)
+            break;
+        const ranges = fileRanges.get(r.relativePath);
+        if (ranges && ranges.some(([s, e]) => r.startLine <= e && r.endLine >= s)) {
+            continue; // overlaps with an already-accepted chunk from same file
+        }
+        accepted.push(r);
+        if (!ranges) {
+            fileRanges.set(r.relativePath, [[r.startLine, r.endLine]]);
+        }
+        else {
+            ranges.push([r.startLine, r.endLine]);
+        }
+    }
+    return accepted;
+}
+/**
+ * Format search results as a compact markdown table for token-efficient output.
+ * Returns file paths, line ranges, scores, and estimated token costs.
+ * Consumers use the Read tool to fetch full code for interesting results.
+ */
+export function formatCompactResults(results, query, rootPath) {
+    if (results.length === 0) {
+        return `No results found for "${query}" in ${rootPath}.`;
+    }
+    const lines = [
+        `Found ${results.length} result(s) for "${query}" in ${rootPath}:\n`,
+        '| # | File | Lines | Score | ~Tokens |',
+        '|---|------|-------|-------|---------|',
+    ];
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const tokens = Math.ceil(r.content.length / 4);
+        lines.push(`| ${i + 1} | \`${r.relativePath}\` | ${r.startLine}-${r.endLine} | ${r.score.toFixed(2)} | ~${tokens} |`);
+    }
+    lines.push('');
+    lines.push('Use the Read tool to view full code for specific results.');
+    return lines.join('\n');
+}
+/**
+ * Format search results as markdown for MCP tool output.
+ */
+export function formatSearchResults(results, query, rootPath) {
+    if (results.length === 0) {
+        return `No results found for "${query}" in ${rootPath}.`;
+    }
+    const lines = [
+        `Found ${results.length} result(s) for "${query}" in ${rootPath}:\n`,
+    ];
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        lines.push(`### Result ${i + 1} of ${results.length}`);
+        lines.push(`**File:** \`${r.relativePath}\` (lines ${r.startLine}-${r.endLine})`);
+        lines.push(`**Language:** ${r.language} | **Score:** ${r.score.toFixed(4)}`);
+        const safeLang = r.language.replace(/[^a-zA-Z0-9_+-]/g, '');
+        lines.push('```' + safeLang);
+        lines.push(r.content);
+        lines.push('```');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=searcher.js.map

package/dist/core/snapshot-io.d.ts

@@ -0,0 +1,6 @@
+import type { FileSnapshot } from './sync.js';
+export declare function loadSnapshot(rootPath: string): FileSnapshot | null;
+export declare function saveSnapshot(rootPath: string, snapshot: FileSnapshot): void;
+export declare function deleteSnapshot(rootPath: string): void;
+export declare function snapshotExists(rootPath: string): boolean;
+//# sourceMappingURL=snapshot-io.d.ts.map

package/dist/core/snapshot-io.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToCollectionName, getSnapshotDir } from '../paths.js';
+function getSnapshotPath(rootPath) {
+    const name = pathToCollectionName(rootPath);
+    return path.join(getSnapshotDir(), `${name}.json`);
+}
+export function loadSnapshot(rootPath) {
+    const filePath = getSnapshotPath(rootPath);
+    try {
+        const data = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        console.warn(`Corrupted snapshot at ${filePath}, ignoring: ${err}`);
+        return null;
+    }
+}
+export function saveSnapshot(rootPath, snapshot) {
+    const filePath = getSnapshotPath(rootPath);
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(snapshot));
+}
+export function deleteSnapshot(rootPath) {
+    const filePath = getSnapshotPath(rootPath);
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch {
+        // Already gone
+    }
+}
+export function snapshotExists(rootPath) {
+    return fs.existsSync(getSnapshotPath(rootPath));
+}
+//# sourceMappingURL=snapshot-io.js.map

package/dist/core/sync.d.ts

@@ -0,0 +1,35 @@
+export interface FileSnapshot {
+    [relativePath: string]: {
+        contentHash: string;
+    };
+}
+export interface SyncResult {
+    added: string[];
+    modified: string[];
+    removed: string[];
+}
+/**
+ * Scan a directory and return relative paths of indexable files.
+ * Respects .gitignore if present.
+ */
+export declare function scanFiles(rootPath: string, customExtensions?: string[], customIgnore?: string[]): Promise<string[]>;
+/**
+ * Build a size+contentHash snapshot for a list of files.
+ */
+export declare function buildSnapshot(rootPath: string, relativePaths: string[]): FileSnapshot;
+/**
+ * Compare current snapshot to a previous one. Returns added, modified, and removed files.
+ * Uses content hash as the authoritative change signal — immune to git ops, IDE formatters,
+ * NFS clock skew, and other mtime-only pitfalls.
+ */
+export declare function diffSnapshots(previous: FileSnapshot, current: FileSnapshot): SyncResult;
+/**
+ * Parse .gitignore content into glob patterns.
+ * Pure function — no filesystem access.
+ */
+export declare function parseGitignorePatterns(content: string): string[];
+/**
+ * Map file extension to language name for the splitter.
+ */
+export declare function extensionToLanguage(ext: string): string;
+//# sourceMappingURL=sync.d.ts.map