lmgrep 0.1.18 → 0.2.1

package/dist/lib/store.d.ts

@@ -1,252 +0,0 @@
-import type { IndexedChunk, SearchResult } from "./types.js";
-/**
- * Resolve the project identity for a directory.
- *
- * For git repos: uses the remote origin URL as identity so that multiple
- * worktrees of the same repo share one index.
- *
- * For non-git directories: falls back to hashing the absolute path.
- *
- * Returns { id, root } where id is the string to hash for the DB path,
- * and root is the project root directory (git toplevel or cwd).
- */
-export declare function resolveProject(cwd: string): {
-    id: string;
-    root: string;
-    branch: string;
-};
-export declare function buildSlug(id: string): string;
-export declare function getDbPath(cwd: string): string;
-/**
- * Compute the DB path using the pre-git-aware scheme (absolute path hash).
- * Used by `lmgrep import` to find legacy indexes.
- */
-export declare function getLegacyDbPath(cwd: string): string;
-/**
- * Find the project root and compute the prefix (subdirectory offset).
- * For git repos, the root is the git toplevel. For non-git dirs, walks up
- * looking for an existing index.
- */
-export declare function findIndexedAncestor(cwd: string): {
-    root: string;
-    prefix: string;
-} | undefined;
-export interface ProjectMetadata {
-    root: string;
-    remote?: string;
-    branch: string;
-    indexedAt: string;
-    /** Full model string used at index time (e.g. "openai:nomic-embed-text") */
-    model?: string;
-    /** Embedding vector dimensions */
-    dimensions?: number;
-}
-/**
- * Extract the base model family name from a full model string.
- * Strips provider prefix (e.g. "openai:", "ollama:") and quantization/tag
- * suffixes (e.g. ":Q4_K_M", ":latest", ":fp16").
- *
- * Examples:
- *   "openai:nomic-embed-text"        → "nomic-embed-text"
- *   "ollama:nomic-embed-text:Q4_K_M" → "nomic-embed-text"
- *   "lmstudio:bge-large-en:fp16"     → "bge-large-en"
- *   "openai:text-embedding-3-small"   → "text-embedding-3-small"
- */
-export declare function extractModelFamily(model: string): string;
-export declare function writeProjectMetadata(cwd: string, extra?: {
-    model?: string;
-    dimensions?: number;
-}): void;
-export declare function readProjectMetadata(dbPath: string): ProjectMetadata | undefined;
-/**
- * Scan all lmgrep indexes and return their metadata.
- */
-export declare function discoverIndexedProjects(): Array<{
-    dbPath: string;
-    metadata: ProjectMetadata;
-}>;
-/**
- * Acquire an exclusive write lock for a project's DB.
- * Returns true if the lock was acquired, false if another process holds it.
- */
-export declare function acquireDbLock(cwd: string): boolean;
-/**
- * Release the write lock for a project's DB.
- */
-export declare function releaseDbLock(cwd: string): void;
-/**
- * Run `fn` while holding the project's write mutex, so concurrent indexers
- * (a watcher plus an ad-hoc `lmgrep index`) can't write at the same time and
- * produce duplicate chunk rows. Waits up to `waitMs` for a busy lock, taking
- * over a lock held by a dead process. Throws if the lock can't be acquired in
- * time.
- */
-export declare function withWriteLock<T>(cwd: string, fn: () => Promise<T>, opts?: {
-    waitMs?: number;
-    pollMs?: number;
-}): Promise<T>;
-/**
- * Check if a write lock is held by a live process.
- */
-export declare function isDbLocked(cwd: string): boolean;
-export interface RunningProcess {
-    pid: number;
-    /** Process title from /proc/<pid>/comm (e.g. "lmgrep-mcp", "lmgrep") */
-    processName: string;
-    /** Full command line */
-    cmdline: string;
-    /** Kind of process: "mcp", "serve", or "cli" */
-    kind: "mcp" | "serve" | "cli";
-    /** Project root from the index metadata */
-    projectRoot?: string;
-    /** Whether this process is maintaining (watching) the index */
-    watching: boolean;
-}
-/**
- * Scan all lock files to find running lmgrep processes,
- * which indexes they hold, and whether they are watching for changes.
- */
-export declare function discoverRunningProcesses(): RunningProcess[];
-export declare class Store {
-    private readonly dbPath;
-    private readonly branch;
-    private db;
-    private chunksTable;
-    private filesTable;
-    private vocabTable;
-    constructor(dbPath: string, branch?: string);
-    static forProject(cwd: string): Store;
-    private connection;
-    private openChunks;
-    private openFiles;
-    private openVocab;
-    hasVocab(): Promise<boolean>;
-    /**
-     * Return the set of vocab terms already embedded in the vocab table.
-     * Used at index time to skip re-embedding.
-     */
-    getVocabTerms(): Promise<Set<string>>;
-    addVocab(entries: Array<{
-        term: string;
-        vector: number[];
-    }>): Promise<void>;
-    /**
-     * ANN search against the vocab table. Returns top-N terms closest to the
-     * given vector by cosine distance.
-     */
-    searchVocab(vector: number[], limit: number, excludeTerms?: Set<string>): Promise<Array<{
-        term: string;
-        score: number;
-    }>>;
-    vocabCount(): Promise<number>;
-    dropVocab(): Promise<void>;
-    addChunks(chunks: IndexedChunk[]): Promise<void>;
-    /**
-     * Delete chunks for files that are no longer referenced by ANY branch.
-     * If another branch still has a file hash entry for a given path,
-     * the chunks are kept (they're shared via content-addressing).
-     */
-    deleteChunksByFiles(filePaths: string[]): Promise<void>;
-    private branchVersionsCache;
-    /**
-     * Map of filePath -> file-version hash for the current branch (cached).
-     * Used to scope search to the exact file versions this branch references,
-     * so stale chunks from another version of the same path are excluded.
-     */
-    getBranchFileVersions(): Promise<Map<string, string> | undefined>;
-    /** Invalidate the branch files cache (call after index/import). */
-    invalidateBranchFilesCache(): void;
-    search(queryVector: number[], limit?: number, filePrefix?: string, typeFilter?: string[], 
-    /** Pass false to skip branch scoping (e.g. for cross-project search). */
-    scopeToBranch?: boolean): Promise<SearchResult[]>;
-    /**
-     * Same as search() but also returns each chunk's vector — needed for
-     * client-side clustering (facet command).
-     */
-    searchWithVectors(queryVector: number[], limit?: number, filePrefix?: string, scopeToBranch?: boolean): Promise<Array<SearchResult & {
-        id: string;
-        vector: number[];
-    }>>;
-    /**
-     * Fetch chunks (with vectors) by id. Used to rehydrate faceting sessions.
-     * Missing ids are silently dropped.
-     */
-    getChunksByIds(ids: string[]): Promise<Array<SearchResult & {
-        id: string;
-        vector: number[];
-    }>>;
-    getIndexedFiles(): Promise<Map<string, string[]>>;
-    getIndexedHashes(): Promise<Set<string>>;
-    /**
-     * Given a set of chunk hashes, return those that already exist in the
-     * chunks table. Runs as batched IN() queries in the DB.
-     */
-    filterExistingChunkHashes(hashes: string[]): Promise<Set<string>>;
-    chunkCount(): Promise<number>;
-    /**
-     * Stream chunk texts (name + content only) in batches. Used by vocab
-     * backfill to avoid loading all chunks into memory at once.
-     */
-    streamChunkTexts(batchSize?: number): AsyncIterable<Array<{
-        name: string;
-        content: string;
-    }>>;
-    getFileHashes(): Promise<Map<string, string>>;
-    /**
-     * Given a set of file hashes, return those that already exist in the
-     * files table on ANY branch. The query runs in the DB, not in JS.
-     */
-    filterKnownFileHashes(hashes: string[]): Promise<Set<string>>;
-    upsertFileHashes(entries: Array<{
-        filePath: string;
-        fileHash: string;
-        branch?: string;
-    }>): Promise<void>;
-    deleteFileHashes(filePaths: string[]): Promise<void>;
-    streamAllChunks(batchSize: number): AsyncGenerator<Record<string, unknown>[]>;
-    /**
-     * Remove redundant rows from the chunks table:
-     *  - exact duplicate ids (identical rows from concurrent unlocked indexing)
-     *  - orphaned versions: chunks whose fileHash is no longer referenced by any
-     *    branch's manifest (left behind when a file was edited on one branch
-     *    while another branch still pointed at the old path). Legacy chunks with
-     *    an empty fileHash are kept.
-     * Rewrites the table from the surviving rows. Loads chunks into memory in
-     * batches, so this is a maintenance operation, not a hot path.
-     */
-    dedupeChunks(): Promise<{
-        before: number;
-        after: number;
-        duplicateIds: number;
-        staleVersions: number;
-    }>;
-    getAllFileEntries(): Promise<Array<{
-        filePath: string;
-        fileHash: string;
-        branch: string;
-    }>>;
-    reset(): Promise<void>;
-    compact(): Promise<void>;
-    /**
-     * Import all chunks and file hashes from another Store's database.
-     * Returns { chunks, files } counts of imported records.
-     */
-    importFrom(sourcePath: string): Promise<{
-        chunks: number;
-        files: number;
-    }>;
-    /**
-     * Return all distinct branch names present in the files table.
-     */
-    getStoredBranches(): Promise<string[]>;
-    /**
-     * Delete all file manifest rows for a given branch.
-     */
-    deleteBranchManifest(branch: string): Promise<void>;
-    /**
-     * Copy another branch's file manifest to this store's branch.
-     * Used to bootstrap a new branch from a merge base.
-     */
-    copyBranchManifest(sourceBranch: string): Promise<number>;
-    close(): Promise<void>;
-}