claude-eidetic 0.1.0 → 0.1.2

package/dist/core/doc-searcher.js

@@ -0,0 +1,65 @@
+import { docCollectionName } from '../paths.js';
+import { loadDocMetadata, isStale } from '../state/doc-metadata.js';
+import { SearchError } from '../errors.js';
+import { deduplicateResults } from './searcher.js';
+const DEFAULT_LIMIT = 5;
+const MAX_LIMIT = 20;
+export async function searchDocuments(query, embedding, vectordb, options = {}) {
+    if (!query || query.trim().length === 0) {
+        throw new SearchError('Search query is required.');
+    }
+    const limit = Math.min(Math.max(1, options.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
+    const metadata = loadDocMetadata();
+    let collectionsToSearch;
+    if (options.library) {
+        const collection = docCollectionName(options.library);
+        const entries = Object.values(metadata).filter((e) => e.collectionName === collection);
+        if (entries.length === 0) {
+            throw new SearchError(`No cached documentation found for library "${options.library}". ` +
+                `Use index_document to cache documentation first.`);
+        }
+        collectionsToSearch = [{ collection, entries }];
+    }
+    else {
+        const collectionMap = new Map();
+        for (const entry of Object.values(metadata)) {
+            const existing = collectionMap.get(entry.collectionName) ?? [];
+            existing.push(entry);
+            collectionMap.set(entry.collectionName, existing);
+        }
+        if (collectionMap.size === 0) {
+            throw new SearchError('No cached documentation found. Use index_document to cache documentation first.');
+        }
+        collectionsToSearch = [...collectionMap.entries()].map(([collection, entries]) => ({
+            collection,
+            entries,
+        }));
+    }
+    const queryVector = await embedding.embed(query);
+    const overFetchLimit = Math.min(limit * 3, MAX_LIMIT);
+    const allResults = [];
+    for (const { collection, entries } of collectionsToSearch) {
+        const exists = await vectordb.hasCollection(collection);
+        if (!exists)
+            continue;
+        const results = await vectordb.search(collection, {
+            queryVector,
+            queryText: query,
+            limit: overFetchLimit,
+        });
+        for (const r of results) {
+            const matchingEntry = entries.find((e) => e.source === r.relativePath);
+            allResults.push({
+                ...r,
+                library: matchingEntry?.library ?? 'unknown',
+                topic: matchingEntry?.topic ?? 'unknown',
+                source: r.relativePath,
+                stale: matchingEntry ? isStale(matchingEntry) : false,
+            });
+        }
+    }
+    allResults.sort((a, b) => b.score - a.score);
+    const deduped = deduplicateResults(allResults, limit);
+    return deduped.map((r) => r);
+}
+//# sourceMappingURL=doc-searcher.js.map

package/dist/core/file-category.d.ts

@@ -0,0 +1,7 @@
+export type FileCategory = 'source' | 'test' | 'doc' | 'config' | 'generated';
+/**
+ * Classify a file by category based on its relative path.
+ * First match wins.
+ */
+export declare function classifyFileCategory(relativePath: string): FileCategory;
+//# sourceMappingURL=file-category.d.ts.map

package/dist/core/file-category.js

@@ -0,0 +1,75 @@
+/**
+ * Classify a file by category based on its relative path.
+ * First match wins.
+ */
+export function classifyFileCategory(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    const segments = normalized.split('/');
+    const filename = segments[segments.length - 1];
+    const lower = normalized.toLowerCase();
+    const filenameLower = filename.toLowerCase();
+    // test
+    if (lower.includes('/__tests__/') ||
+        lower.includes('.test.') ||
+        lower.includes('.spec.') ||
+        lower.includes('_test.') ||
+        lower.includes('_spec.') ||
+        filenameLower.startsWith('test_') ||
+        filenameLower.startsWith('test-')) {
+        return 'test';
+    }
+    // doc
+    const ext = filename.includes('.') ? filename.slice(filename.lastIndexOf('.')).toLowerCase() : '';
+    if (['.md', '.mdx', '.rst', '.txt'].includes(ext) ||
+        segments.some((s) => s.toLowerCase() === 'docs' || s.toLowerCase() === 'doc') ||
+        /^readme/i.test(filename) ||
+        /^changelog/i.test(filename) ||
+        /^license/i.test(filename)) {
+        return 'doc';
+    }
+    // generated
+    if (lower.includes('/dist/') ||
+        lower.startsWith('dist/') ||
+        lower.includes('/build/') ||
+        lower.startsWith('build/') ||
+        lower.includes('/generated/') ||
+        lower.startsWith('generated/') ||
+        lower.includes('.generated.') ||
+        /\.[gG]\./.test(filename)) {
+        return 'generated';
+    }
+    // config
+    if (isConfigFile(normalized, filename, ext, segments)) {
+        return 'config';
+    }
+    return 'source';
+}
+function isConfigFile(normalized, filename, ext, segments) {
+    const filenameLower = filename.toLowerCase();
+    // Explicit filename matches
+    if (filenameLower === 'package.json')
+        return true;
+    if (filenameLower === 'makefile')
+        return true;
+    if (filenameLower === 'dockerfile')
+        return true;
+    if (/^tsconfig.*\.json$/.test(filenameLower))
+        return true;
+    if (filenameLower.startsWith('docker-compose'))
+        return true;
+    if (filenameLower.startsWith('.eslintrc'))
+        return true;
+    if (filenameLower.startsWith('.prettierrc'))
+        return true;
+    // *.config.* pattern
+    if (filename.includes('.config.'))
+        return true;
+    // .yaml/.yml/.toml not under src/
+    if (['.yaml', '.yml', '.toml'].includes(ext)) {
+        const underSrc = segments.some((s) => s.toLowerCase() === 'src');
+        if (!underSrc)
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=file-category.js.map

package/dist/core/indexer.js

@@ -7,6 +7,7 @@ import { scanFiles, buildSnapshot, diffSnapshots, extensionToLanguage } from './
 import { getConfig } from '../config.js';
 import { normalizePath, pathToCollectionName } from '../paths.js';
 import { IndexingError } from '../errors.js';
+import { classifyFileCategory } from './file-category.js';
 import { loadSnapshot, saveSnapshot } from './snapshot-io.js';
 export { previewCodebase } from './preview.js';
 export { saveSnapshot, deleteSnapshot, snapshotExists } from './snapshot-io.js';
@@ -75,7 +76,9 @@ export async function indexCodebase(rootPath, embedding, vectordb, force = false
     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 batchResults = await Promise.all(
+        // eslint-disable-next-line @typescript-eslint/require-await
+        batch.map(async (relPath) => {
             const fullPath = path.join(normalizedPath, relPath);
             try {
                 const code = fs.readFileSync(fullPath, 'utf-8');
@@ -92,7 +95,7 @@ export async function indexCodebase(rootPath, embedding, vectordb, force = false
                 return { chunks, failed: false };
             }
             catch (err) {
-                console.warn(`Failed to process "${relPath}": ${err}`);
+                console.warn(`Failed to process "${relPath}":`, err);
                 return { chunks: [], failed: true };
             }
         }));
@@ -122,7 +125,7 @@ export async function indexCodebase(rootPath, embedding, vectordb, force = false
             parseFailures,
         };
     }
-    const chunkTexts = allChunks.map(c => c.content);
+    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)})`);
@@ -130,7 +133,7 @@ export async function indexCodebase(rootPath, embedding, vectordb, force = false
     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 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);
@@ -146,6 +149,11 @@ export async function indexCodebase(rootPath, embedding, vectordb, force = false
             endLine: chunk.endLine,
             fileExtension: path.extname(chunk.filePath),
             language: chunk.language,
+            fileCategory: classifyFileCategory(chunk.filePath),
+            symbolName: chunk.symbolName,
+            symbolKind: chunk.symbolKind,
+            symbolSignature: chunk.symbolSignature,
+            parentSymbol: chunk.parentSymbol,
         }));
         await vectordb.insert(collectionName, documents);
         processedChunks += batch.length;

package/dist/core/preview.d.ts

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

package/dist/core/preview.js

@@ -2,7 +2,7 @@ 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) {
+export async function previewCodebase(rootPath, customExtensions, customIgnorePatterns) {
     const normalizedPath = normalizePath(rootPath);
     const filePaths = await scanFiles(normalizedPath, customExtensions, customIgnorePatterns);
     const byExtension = {};
@@ -20,7 +20,6 @@ export async function previewCodebase(rootPath, embedding, customExtensions, cus
         .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 {
@@ -28,11 +27,9 @@ export async function previewCodebase(rootPath, embedding, customExtensions, cus
             totalBytes += stat.size;
         }
         catch {
-            // File may have disappeared between scan and stat
+            // 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 = [];

package/dist/core/repo-map.d.ts

@@ -0,0 +1,33 @@
+import type { VectorDB, SymbolEntry } from '../vectordb/types.js';
+export interface RepoMapOptions {
+    pathFilter?: string;
+    kindFilter?: string;
+    maxTokens?: number;
+}
+export interface ListSymbolsOptions {
+    pathFilter?: string;
+    kindFilter?: string;
+    nameFilter?: string;
+}
+export interface SymbolSource {
+    getSymbols(collectionName: string, options?: RepoMapOptions | ListSymbolsOptions): Promise<SymbolEntry[]>;
+}
+export declare class VectorDBSymbolSource implements SymbolSource {
+    private vectordb;
+    constructor(vectordb: VectorDB);
+    getSymbols(collectionName: string, options?: RepoMapOptions | ListSymbolsOptions): Promise<SymbolEntry[]>;
+}
+/**
+ * Convert a glob-like pattern to a regex for path filtering.
+ * Supports * (non-separator) and ** (any path segment).
+ */
+export declare function matchesPathFilter(relativePath: string, pattern: string): boolean;
+/**
+ * Generate a structured repo map grouped by file, with methods nested under classes.
+ */
+export declare function generateRepoMap(rootPath: string, source: SymbolSource, options?: RepoMapOptions): Promise<string>;
+/**
+ * List symbols as a compact Name|Kind|Location table.
+ */
+export declare function listSymbolsTable(rootPath: string, source: SymbolSource, options?: ListSymbolsOptions): Promise<string>;
+//# sourceMappingURL=repo-map.d.ts.map

package/dist/core/repo-map.js

@@ -0,0 +1,144 @@
+import { pathToCollectionName } from '../paths.js';
+export class VectorDBSymbolSource {
+    vectordb;
+    constructor(vectordb) {
+        this.vectordb = vectordb;
+    }
+    async getSymbols(collectionName, options) {
+        const all = await this.vectordb.listSymbols(collectionName);
+        let result = all;
+        const pathFilter = options?.pathFilter;
+        if (pathFilter) {
+            result = result.filter((s) => matchesPathFilter(s.relativePath, pathFilter));
+        }
+        const kindFilter = options?.kindFilter;
+        if (kindFilter) {
+            const kind = kindFilter.toLowerCase();
+            result = result.filter((s) => s.kind.toLowerCase() === kind);
+        }
+        const nameFilter = options?.nameFilter;
+        if (nameFilter) {
+            const lower = nameFilter.toLowerCase();
+            result = result.filter((s) => s.name.toLowerCase().includes(lower));
+        }
+        return result;
+    }
+}
+/**
+ * Convert a glob-like pattern to a regex for path filtering.
+ * Supports * (non-separator) and ** (any path segment).
+ */
+export function matchesPathFilter(relativePath, pattern) {
+    // Escape regex special chars except * which we handle
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '\uFFFD') // placeholder for **
+        .replace(/\*/g, '[^/]*')
+        .replace(/\uFFFD/g, '.*');
+    const regex = new RegExp(`^${escaped}$`);
+    return regex.test(relativePath);
+}
+/**
+ * Deduplicate symbol entries: prefer those with a signature, then by first occurrence.
+ */
+function deduplicateSymbols(symbols) {
+    const seen = new Map();
+    for (const sym of symbols) {
+        const key = `${sym.relativePath}:${sym.name}:${sym.kind}`;
+        const existing = seen.get(key);
+        if (!existing || (!existing.signature && sym.signature)) {
+            seen.set(key, sym);
+        }
+    }
+    return [...seen.values()];
+}
+/**
+ * Generate a structured repo map grouped by file, with methods nested under classes.
+ */
+export async function generateRepoMap(rootPath, source, options) {
+    const collectionName = pathToCollectionName(rootPath);
+    const maxTokens = options?.maxTokens ?? 4000;
+    const maxChars = maxTokens * 4;
+    const symbols = await source.getSymbols(collectionName, options);
+    if (symbols.length === 0) {
+        return '(no symbols found — codebase may not be indexed yet)';
+    }
+    const deduped = deduplicateSymbols(symbols);
+    // Group by file
+    const byFile = new Map();
+    for (const sym of deduped) {
+        const list = byFile.get(sym.relativePath) ?? [];
+        list.push(sym);
+        byFile.set(sym.relativePath, list);
+    }
+    // Sort files
+    const files = [...byFile.keys()].sort();
+    const lines = [];
+    let totalChars = 0;
+    for (const file of files) {
+        const fileSymbols = byFile.get(file) ?? [];
+        // Separate top-level from methods (those with a parentName)
+        const topLevel = fileSymbols.filter((s) => !s.parentName);
+        const methods = fileSymbols.filter((s) => s.parentName !== undefined);
+        // Build method lookup by parent
+        const methodsByParent = new Map();
+        for (const m of methods) {
+            const list = methodsByParent.get(m.parentName) ?? [];
+            list.push(m);
+            methodsByParent.set(m.parentName, list);
+        }
+        const fileHeader = `${file}:`;
+        if (totalChars + fileHeader.length > maxChars)
+            break;
+        lines.push(fileHeader);
+        totalChars += fileHeader.length + 1;
+        for (const sym of topLevel) {
+            const sig = sym.signature ? ` ${sym.signature.trim()}` : ` ${sym.name}`;
+            const line = `  [${sym.kind}]${sig}`;
+            if (totalChars + line.length > maxChars) {
+                lines.push('  ...(truncated)');
+                return lines.join('\n');
+            }
+            lines.push(line);
+            totalChars += line.length + 1;
+            // Nest methods under this symbol if it's a container
+            const children = methodsByParent.get(sym.name) ?? [];
+            for (const child of children) {
+                const childSig = child.signature ? ` ${child.signature.trim()}` : ` ${child.name}`;
+                const childLine = `    [${child.kind}]${childSig}`;
+                if (totalChars + childLine.length > maxChars) {
+                    lines.push('    ...(truncated)');
+                    return lines.join('\n');
+                }
+                lines.push(childLine);
+                totalChars += childLine.length + 1;
+            }
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * List symbols as a compact Name|Kind|Location table.
+ */
+export async function listSymbolsTable(rootPath, source, options) {
+    const collectionName = pathToCollectionName(rootPath);
+    const symbols = await source.getSymbols(collectionName, options);
+    if (symbols.length === 0) {
+        return '(no symbols found)';
+    }
+    const deduped = deduplicateSymbols(symbols);
+    deduped.sort((a, b) => {
+        const pathCmp = a.relativePath.localeCompare(b.relativePath);
+        if (pathCmp !== 0)
+            return pathCmp;
+        return a.startLine - b.startLine;
+    });
+    const header = 'Name | Kind | Location';
+    const sep = '-----|------|--------';
+    const rows = deduped.map((s) => {
+        const location = `${s.relativePath}:${s.startLine}`;
+        return `${s.name} | ${s.kind} | ${location}`;
+    });
+    return [header, sep, ...rows].join('\n');
+}
+//# sourceMappingURL=repo-map.js.map

package/dist/core/searcher.d.ts

@@ -5,20 +5,8 @@ export interface SearchOptions {
     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 applyCategoryBoost(results: SearchResult[]): SearchResult[];
 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

@@ -5,32 +5,38 @@ 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 overFetchLimit = Math.min(limit * 5, MAX_LIMIT);
     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);
+    return deduplicateResults(applyCategoryBoost(results), limit);
+}
+const CATEGORY_BOOST = {
+    source: 1.0,
+    test: 0.75,
+    doc: 0.65,
+    config: 0.7,
+    generated: 0.6,
+};
+const DEFAULT_BOOST = 1.0; // legacy points without fileCategory get no penalty
+export function applyCategoryBoost(results) {
+    return results
+        .map((r) => ({
+        ...r,
+        score: r.score * (CATEGORY_BOOST[r.fileCategory ?? ''] ?? DEFAULT_BOOST),
+    }))
+        .sort((a, b) => b.score - a.score);
 }
-/**
- * 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][]
@@ -39,7 +45,7 @@ export function deduplicateResults(results, limit) {
         if (accepted.length >= limit)
             break;
         const ranges = fileRanges.get(r.relativePath);
-        if (ranges && ranges.some(([s, e]) => r.startLine <= e && r.endLine >= s)) {
+        if (ranges?.some(([s, e]) => r.startLine <= e && r.endLine >= s)) {
             continue; // overlaps with an already-accepted chunk from same file
         }
         accepted.push(r);
@@ -52,11 +58,6 @@ export function deduplicateResults(results, limit) {
     }
     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}.`;
@@ -75,16 +76,11 @@ export function formatCompactResults(results, query, rootPath) {
     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`,
-    ];
+    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}`);

package/dist/core/snapshot-io.js

@@ -14,7 +14,7 @@ export function loadSnapshot(rootPath) {
     catch (err) {
         if (err.code === 'ENOENT')
             return null;
-        console.warn(`Corrupted snapshot at ${filePath}, ignoring: ${err}`);
+        console.warn(`Corrupted snapshot at ${filePath}, ignoring:`, err);
         return null;
     }
 }
@@ -30,7 +30,7 @@ export function deleteSnapshot(rootPath) {
         fs.unlinkSync(filePath);
     }
     catch {
-        // Already gone
+        // ignore — file may already be gone
     }
 }
 export function snapshotExists(rootPath) {

package/dist/core/sync.d.ts

@@ -1,35 +1,15 @@
-export interface FileSnapshot {
-    [relativePath: string]: {
-        contentHash: string;
-    };
-}
-export interface SyncResult {
+export type FileSnapshot = Record<string, {
+    contentHash: string;
+}>;
+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;
+export {};
 //# sourceMappingURL=sync.d.ts.map