@spark-agents/engram 0.1.0

package/dist/reranker.d.ts

@@ -0,0 +1,15 @@
+export interface Reranker {
+    /** Rerank candidates by (query, document) relevance. Returns reordered with updated scores. */
+    rerank(query: string, candidates: Array<{
+        text: string;
+        score: number;
+    }>): Promise<Array<{
+        text: string;
+        score: number;
+        rerankerScore: number;
+    }>>;
+    /** Clean up model resources */
+    close(): Promise<void>;
+}
+export declare function createLightweightReranker(): Reranker;
+export declare function createReranker(): Promise<Reranker | null>;

package/dist/reranker.js

@@ -0,0 +1,104 @@
+import { AutoModelForSequenceClassification, AutoTokenizer, env } from "@xenova/transformers";
+const MODEL_NAME = "Xenova/ms-marco-MiniLM-L-12-v2";
+const MAX_INPUT_LENGTH = 512;
+const MIN_QUERY_TERM_LEN = 3;
+function toTerms(text) {
+    return text
+        .toLowerCase()
+        .split(/\W+/)
+        .filter((term) => term.length >= MIN_QUERY_TERM_LEN);
+}
+function extractRerankerScores(logits, candidateCount) {
+    if (candidateCount <= 0) {
+        return [];
+    }
+    const rawData = logits?.data ? Array.from(logits.data) : [];
+    if (rawData.length === 0) {
+        return Array.from({ length: candidateCount }, () => Number.NEGATIVE_INFINITY);
+    }
+    const dims = logits?.dims ? Array.from(logits.dims, (value) => Number(value)) : [];
+    const classesPerCandidate = dims.length >= 2 ? Math.max(1, dims[dims.length - 1] ?? 1) : Math.max(1, Math.floor(rawData.length / candidateCount));
+    const scores = [];
+    for (let i = 0; i < candidateCount; i += 1) {
+        const offset = i * classesPerCandidate;
+        if (classesPerCandidate === 1) {
+            scores.push(rawData[offset] ?? rawData[i] ?? Number.NEGATIVE_INFINITY);
+            continue;
+        }
+        // For two-class heads, use the positive class logit (last class).
+        scores.push(rawData[offset + classesPerCandidate - 1] ?? Number.NEGATIVE_INFINITY);
+    }
+    return scores;
+}
+export function createLightweightReranker() {
+    return {
+        async rerank(query, candidates) {
+            if (candidates.length === 0) {
+                return [];
+            }
+            const queryTerms = new Set(toTerms(query));
+            const reranked = candidates.map((candidate) => {
+                const docTerms = new Set(toTerms(candidate.text));
+                const overlapCount = Array.from(queryTerms).filter((term) => docTerms.has(term)).length;
+                const coverage = queryTerms.size > 0 ? overlapCount / queryTerms.size : 0;
+                const rerankerScore = 0.6 * candidate.score + 0.4 * coverage;
+                return {
+                    text: candidate.text,
+                    score: candidate.score,
+                    rerankerScore,
+                };
+            });
+            reranked.sort((a, b) => b.rerankerScore - a.rerankerScore);
+            return reranked;
+        },
+        async close() { },
+    };
+}
+export async function createReranker() {
+    try {
+        if (process.env.NODE_ENV === "production") {
+            env.allowRemoteModels = false;
+        }
+        const localFilesOnly = env.allowRemoteModels === false;
+        const tokenizer = await AutoTokenizer.from_pretrained(MODEL_NAME, {
+            local_files_only: localFilesOnly,
+        });
+        const model = await AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, {
+            local_files_only: localFilesOnly,
+        });
+        return {
+            async rerank(query, candidates) {
+                if (candidates.length === 0) {
+                    return [];
+                }
+                const queries = candidates.map(() => query);
+                const documents = candidates.map((candidate) => candidate.text);
+                const inputs = tokenizer(queries, {
+                    text_pair: documents,
+                    padding: true,
+                    truncation: true,
+                    max_length: MAX_INPUT_LENGTH,
+                });
+                const outputs = await model(inputs);
+                const scores = extractRerankerScores(outputs?.logits, candidates.length);
+                const reranked = candidates.map((candidate, i) => ({
+                    text: candidate.text,
+                    score: candidate.score,
+                    rerankerScore: scores[i] ?? Number.NEGATIVE_INFINITY,
+                }));
+                reranked.sort((a, b) => b.rerankerScore - a.rerankerScore);
+                return reranked;
+            },
+            async close() {
+                if (typeof model.dispose === "function") {
+                    await model.dispose();
+                }
+            },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Engram: Cross-encoder reranker unavailable: ${message}`);
+        return null;
+    }
+}

package/dist/search.d.ts

@@ -0,0 +1,33 @@
+import type { EmbeddingClient, IndexManager, ScoredChunk, SearchOptions, SearchResult } from "./types.js";
+import type { Reranker } from "./reranker.js";
+/** Create a unique key for a chunk (for deduplication/merging) */
+export declare function chunkKey(chunk: ScoredChunk): string;
+/** Compute RRF scores for a ranked list of chunks */
+export declare function computeRRFScores(chunks: ScoredChunk[], weight: number, k: number): Map<string, {
+    chunk: ScoredChunk;
+    score: number;
+}>;
+/** Apply exponential time decay to scores */
+export declare function applyTimeDecay(results: Array<{
+    chunk: ScoredChunk;
+    score: number;
+}>, halfLifeDays: number): void;
+/** Apply source balancing — demote excess session results */
+export declare function applySourceBalancing(results: Array<{
+    chunk: ScoredChunk;
+    score: number;
+}>, maxSessionShare: number, maxResults: number): Array<{
+    chunk: ScoredChunk;
+    score: number;
+}>;
+export declare function search(query: string, embedding: EmbeddingClient, index: IndexManager, options: SearchOptions & {
+    vectorWeight?: number;
+    bm25Weight?: number;
+    rrfK?: number;
+    timeDecay?: {
+        enabled: boolean;
+        halfLifeDays: number;
+    };
+    maxSessionShare?: number;
+    reranker?: Reranker | null;
+}): Promise<SearchResult[]>;

package/dist/search.js

@@ -0,0 +1,203 @@
+const DEFAULT_VECTOR_WEIGHT = 0.7;
+const DEFAULT_BM25_WEIGHT = 0.3;
+const DEFAULT_RRF_K = 60;
+const DEFAULT_MAX_RESULTS = 10;
+const DEFAULT_MIN_SCORE = 0.0;
+const CO_OCCURRENCE_BONUS = 0.05;
+const CANDIDATE_TOP_K = 50;
+const RERANK_TOP_K = 20;
+function getChunkTimestampMs(chunk) {
+    return chunk.indexedAt ?? null;
+}
+/** Create a unique key for a chunk (for deduplication/merging) */
+export function chunkKey(chunk) {
+    return `${chunk.fileKey}:${chunk.startLine}:${chunk.endLine}`;
+}
+/** Compute RRF scores for a ranked list of chunks */
+export function computeRRFScores(chunks, weight, k) {
+    const scores = new Map();
+    if (chunks.length === 0 || weight <= 0) {
+        return scores;
+    }
+    const safeK = Number.isFinite(k) && k >= 0 ? k : DEFAULT_RRF_K;
+    for (let i = 0; i < chunks.length; i += 1) {
+        const chunk = chunks[i];
+        const key = chunkKey(chunk);
+        if (scores.has(key)) {
+            continue;
+        }
+        const rank = i + 1;
+        scores.set(key, {
+            chunk,
+            score: weight / (safeK + rank),
+        });
+    }
+    return scores;
+}
+/** Apply exponential time decay to scores */
+export function applyTimeDecay(results, halfLifeDays) {
+    if (halfLifeDays <= 0 || !Number.isFinite(halfLifeDays)) {
+        return;
+    }
+    const nowMs = Date.now();
+    const msPerDay = 24 * 60 * 60 * 1000;
+    for (const result of results) {
+        const timestampMs = getChunkTimestampMs(result.chunk);
+        if (timestampMs === null) {
+            continue;
+        }
+        const ageDays = Math.max(0, (nowMs - timestampMs) / msPerDay);
+        const decayMultiplier = Math.pow(0.5, ageDays / halfLifeDays);
+        result.score *= decayMultiplier;
+    }
+}
+/** Apply source balancing — demote excess session results */
+export function applySourceBalancing(results, maxSessionShare, maxResults) {
+    if (results.length === 0 || maxResults <= 0) {
+        return [];
+    }
+    if (!Number.isFinite(maxSessionShare) || maxSessionShare >= 1) {
+        return results.slice();
+    }
+    const sessionCap = Math.max(0, Math.floor(maxSessionShare * maxResults));
+    const balanced = [];
+    let sessionCount = 0;
+    for (const result of results) {
+        if (result.chunk.source === "sessions") {
+            if (sessionCount < sessionCap) {
+                balanced.push(result);
+                sessionCount += 1;
+            }
+            continue;
+        }
+        balanced.push(result);
+    }
+    return balanced;
+}
+export async function search(query, embedding, index, options) {
+    const normalizedQuery = query.trim();
+    if (normalizedQuery.length === 0) {
+        return [];
+    }
+    const maxResults = options.maxResults ?? DEFAULT_MAX_RESULTS;
+    if (maxResults <= 0) {
+        return [];
+    }
+    const minScore = options.minScore ?? DEFAULT_MIN_SCORE;
+    const vectorWeight = options.vectorWeight ?? DEFAULT_VECTOR_WEIGHT;
+    const bm25Weight = options.bm25Weight ?? DEFAULT_BM25_WEIGHT;
+    const rrfK = options.rrfK ?? DEFAULT_RRF_K;
+    let queryVector = null;
+    try {
+        queryVector = await embedding.embedText(normalizedQuery, "RETRIEVAL_QUERY");
+    }
+    catch {
+        queryVector = null;
+    }
+    const bm25Promise = Promise.resolve()
+        .then(() => index.searchBM25(normalizedQuery, CANDIDATE_TOP_K))
+        .catch(() => []);
+    const vectorPromise = queryVector
+        ? Promise.resolve()
+            .then(() => index.searchVector(queryVector, CANDIDATE_TOP_K))
+            .catch(() => [])
+        : Promise.resolve([]);
+    const [bm25Results, vectorResults] = await Promise.all([bm25Promise, vectorPromise]);
+    if (bm25Results.length === 0 && vectorResults.length === 0) {
+        return [];
+    }
+    const bm25Scores = computeRRFScores(bm25Results, bm25Weight, rrfK);
+    const vectorScores = computeRRFScores(vectorResults, vectorWeight, rrfK);
+    const merged = new Map();
+    const mergeScores = (scores, flags) => {
+        for (const [key, value] of scores) {
+            const existing = merged.get(key);
+            if (existing) {
+                existing.score += value.score;
+                existing.inBM25 ||= flags.inBM25;
+                existing.inVector ||= flags.inVector;
+            }
+            else {
+                merged.set(key, {
+                    chunk: value.chunk,
+                    score: value.score,
+                    inBM25: flags.inBM25,
+                    inVector: flags.inVector,
+                });
+            }
+        }
+    };
+    mergeScores(bm25Scores, { inBM25: true, inVector: false });
+    mergeScores(vectorScores, { inBM25: false, inVector: true });
+    const fused = [];
+    for (const entry of merged.values()) {
+        if (entry.inBM25 && entry.inVector) {
+            entry.score += CO_OCCURRENCE_BONUS;
+        }
+        fused.push({ chunk: entry.chunk, score: entry.score });
+    }
+    fused.sort((a, b) => b.score - a.score);
+    if (options.reranker && fused.length > 0) {
+        const topK = Math.min(RERANK_TOP_K, fused.length);
+        const topCandidates = fused.slice(0, topK);
+        try {
+            const reranked = await options.reranker.rerank(normalizedQuery, topCandidates.map((row) => ({
+                text: row.chunk.text,
+                score: row.score,
+            })));
+            if (reranked.length > 0) {
+                const candidatesByText = new Map();
+                for (const row of topCandidates) {
+                    const list = candidatesByText.get(row.chunk.text);
+                    if (list) {
+                        list.push(row);
+                    }
+                    else {
+                        candidatesByText.set(row.chunk.text, [row]);
+                    }
+                }
+                const rerankedRows = [];
+                for (const row of reranked) {
+                    const matches = candidatesByText.get(row.text);
+                    const match = matches?.shift();
+                    if (!match) {
+                        continue;
+                    }
+                    match.score = row.rerankerScore;
+                    rerankedRows.push(match);
+                }
+                const consumed = new Set(rerankedRows);
+                for (const row of topCandidates) {
+                    if (!consumed.has(row)) {
+                        rerankedRows.push(row);
+                    }
+                }
+                const rest = fused.slice(topK);
+                fused.length = 0;
+                fused.push(...rerankedRows, ...rest);
+            }
+        }
+        catch {
+            // Ignore reranker failures and keep RRF ordering.
+        }
+    }
+    if (options.timeDecay?.enabled === true) {
+        applyTimeDecay(fused, options.timeDecay.halfLifeDays);
+        fused.sort((a, b) => b.score - a.score);
+    }
+    const balanced = options.maxSessionShare === undefined
+        ? fused
+        : applySourceBalancing(fused, options.maxSessionShare, maxResults);
+    return balanced
+        .filter((row) => row.score >= minScore)
+        .slice(0, maxResults)
+        .map(({ chunk, score }) => ({
+        path: chunk.fileKey,
+        startLine: chunk.startLine,
+        endLine: chunk.endLine,
+        score,
+        snippet: chunk.text,
+        source: chunk.source,
+        citation: `${chunk.fileKey}#L${chunk.startLine}-L${chunk.endLine}`,
+    }));
+}

package/dist/store.d.ts

@@ -0,0 +1,6 @@
+import type { IndexManager } from "./types.js";
+export declare function createIndexManager(params: {
+    dbPath: string;
+    dimensions: number;
+    workspaceDir: string;
+}): IndexManager;

package/dist/store.js

@@ -0,0 +1,272 @@
+import fs from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+function toVectorBlob(vec) {
+    return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+function toScoredChunk(chunk, score, indexedAt) {
+    return {
+        fileKey: chunk.file_key,
+        startLine: chunk.start_line,
+        endLine: chunk.end_line,
+        text: chunk.text,
+        score,
+        source: chunk.source,
+        headingContext: chunk.heading_context ?? undefined,
+        indexedAt,
+    };
+}
+export function createIndexManager(params) {
+    const { dbPath, dimensions, workspaceDir } = params;
+    if (!Number.isInteger(dimensions) || dimensions <= 0) {
+        throw new Error(`Invalid vector dimensions: ${dimensions}`);
+    }
+    if (dbPath !== ":memory:") {
+        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    }
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    let vectorEnabled = true;
+    try {
+        sqliteVec.load(db);
+    }
+    catch {
+        vectorEnabled = false;
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS files (
+      file_key TEXT PRIMARY KEY,
+      content_hash TEXT NOT NULL,
+      source TEXT NOT NULL,
+      indexed_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS chunks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_key TEXT NOT NULL,
+      start_line INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      text TEXT NOT NULL,
+      heading_context TEXT,
+      source TEXT NOT NULL,
+      FOREIGN KEY (file_key) REFERENCES files(file_key)
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+      text,
+      content='chunks',
+      content_rowid='id',
+      tokenize='porter unicode61'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+      INSERT INTO chunks_fts(rowid, text) VALUES (new.id, new.text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+      INSERT INTO chunks_fts(chunks_fts, rowid, text) VALUES ('delete', old.id, old.text);
+    END;
+
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+  `);
+    if (vectorEnabled) {
+        db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_vec USING vec0(
+        chunk_id INTEGER PRIMARY KEY,
+        embedding float[${dimensions}]
+      );
+    `);
+    }
+    const deleteVectorsByFileStmt = vectorEnabled
+        ? db.prepare(`DELETE FROM chunks_vec WHERE chunk_id IN (SELECT id FROM chunks WHERE file_key = ?);`)
+        : null;
+    const deleteChunksByFileStmt = db.prepare(`DELETE FROM chunks WHERE file_key = ?;`);
+    const deleteFileStmt = db.prepare(`DELETE FROM files WHERE file_key = ?;`);
+    const insertFileStmt = db.prepare(`INSERT INTO files (file_key, content_hash, source, indexed_at) VALUES (?, ?, ?, ?);`);
+    const insertChunkStmt = db.prepare(`INSERT INTO chunks (file_key, start_line, end_line, text, heading_context, source) VALUES (?, ?, ?, ?, ?, ?);`);
+    const bm25Stmt = db.prepare(`
+    SELECT
+      c.id,
+      c.file_key,
+      c.start_line,
+      c.end_line,
+      c.text,
+      c.heading_context,
+      c.source,
+      f.indexed_at,
+      rank
+    FROM chunks_fts fts
+    JOIN chunks c ON c.id = fts.rowid
+    JOIN files f ON f.file_key = c.file_key
+    WHERE chunks_fts MATCH ?
+    ORDER BY rank
+    LIMIT ?;
+  `);
+    const vectorSearchStmt = vectorEnabled
+        ? db.prepare(`
+        SELECT chunk_id, distance
+        FROM chunks_vec
+        WHERE embedding MATCH ? AND k = ?
+        ORDER BY distance;
+      `)
+        : null;
+    const getChunkByIdStmt = db.prepare(`
+    SELECT id, file_key, start_line, end_line, text, heading_context, source
+    FROM chunks
+    WHERE id = ?;
+  `);
+    const getFileIndexedAtStmt = db.prepare(`SELECT indexed_at FROM files WHERE file_key = ?;`);
+    const getFileHashStmt = db.prepare(`SELECT content_hash FROM files WHERE file_key = ?;`);
+    const fileCountStmt = db.prepare(`SELECT COUNT(*) AS count FROM files;`);
+    const chunkCountStmt = db.prepare(`SELECT COUNT(*) AS count FROM chunks;`);
+    const sourceStatsStmt = db.prepare(`
+    SELECT
+      s.source AS source,
+      COALESCE(f.files, 0) AS files,
+      COALESCE(c.chunks, 0) AS chunks
+    FROM (
+      SELECT 'memory' AS source
+      UNION ALL
+      SELECT 'sessions' AS source
+    ) AS s
+    LEFT JOIN (
+      SELECT source, COUNT(*) AS files
+      FROM files
+      GROUP BY source
+    ) AS f ON f.source = s.source
+    LEFT JOIN (
+      SELECT source, COUNT(*) AS chunks
+      FROM chunks
+      GROUP BY source
+    ) AS c ON c.source = s.source;
+  `);
+    const removeFileTx = db.transaction((fileKey) => {
+        deleteVectorsByFileStmt?.run(fileKey);
+        deleteChunksByFileStmt.run(fileKey);
+        deleteFileStmt.run(fileKey);
+    });
+    const indexFileTx = db.transaction((file, chunks, vectors) => {
+        if (chunks.length !== vectors.length) {
+            throw new Error(`Chunk/vector length mismatch for "${file.fileKey}": ${chunks.length} chunks vs ${vectors.length} vectors`);
+        }
+        deleteVectorsByFileStmt?.run(file.fileKey);
+        deleteChunksByFileStmt.run(file.fileKey);
+        deleteFileStmt.run(file.fileKey);
+        insertFileStmt.run(file.fileKey, file.contentHash, file.source, file.indexedAt);
+        for (let i = 0; i < chunks.length; i += 1) {
+            const chunk = chunks[i];
+            const vector = vectors[i];
+            if (vector.length !== dimensions) {
+                throw new Error(`Vector dimension mismatch at chunk ${i} for "${file.fileKey}": expected ${dimensions}, received ${vector.length}`);
+            }
+            const insertResult = insertChunkStmt.run(file.fileKey, chunk.startLine, chunk.endLine, chunk.text, chunk.headingContext ?? null, file.source);
+            if (vectorEnabled) {
+                const chunkId = Number(insertResult.lastInsertRowid);
+                const insertVectorStmt = db.prepare(`INSERT INTO chunks_vec (chunk_id, embedding) VALUES (${chunkId}, ?);`);
+                insertVectorStmt.run(toVectorBlob(vector));
+            }
+        }
+    });
+    return {
+        indexFile(file, chunks, vectors) {
+            indexFileTx(file, chunks, vectors);
+        },
+        removeFile(fileKey) {
+            removeFileTx(fileKey);
+        },
+        searchBM25(query, topK) {
+            if (topK <= 0) {
+                return [];
+            }
+            try {
+                const rows = bm25Stmt.all(query, topK);
+                return rows.map((row) => {
+                    const score = 1 / (1 + Math.abs(row.rank));
+                    return toScoredChunk(row, score, row.indexed_at);
+                });
+            }
+            catch {
+                return [];
+            }
+        },
+        searchVector(queryVec, topK) {
+            if (!vectorEnabled || vectorSearchStmt === null || topK <= 0) {
+                return [];
+            }
+            const hits = vectorSearchStmt.all(toVectorBlob(queryVec), topK);
+            if (hits.length === 0) {
+                return [];
+            }
+            const results = [];
+            for (const hit of hits) {
+                const chunk = getChunkByIdStmt.get(hit.chunk_id);
+                if (!chunk) {
+                    continue;
+                }
+                const indexedAt = getFileIndexedAtStmt.get(chunk.file_key)?.indexed_at;
+                const score = 1 / (1 + hit.distance);
+                results.push(toScoredChunk(chunk, score, indexedAt));
+            }
+            return results;
+        },
+        getFileHash(fileKey) {
+            const row = getFileHashStmt.get(fileKey);
+            return row?.content_hash ?? null;
+        },
+        readFileContent(relPath, from, lines) {
+            const normalizedRelPath = path.posix
+                .normalize(relPath.replace(/\\/g, "/").replace(/^\.\/+/, ""))
+                .replace(/^\/+/, "");
+            if (normalizedRelPath.length === 0 ||
+                normalizedRelPath === "." ||
+                normalizedRelPath === ".." ||
+                normalizedRelPath.startsWith("../")) {
+                return null;
+            }
+            const absPath = path.resolve(workspaceDir, normalizedRelPath);
+            if (!fs.existsSync(absPath)) {
+                return null;
+            }
+            const realWorkspace = fs.realpathSync(workspaceDir);
+            const realAbs = fs.realpathSync(absPath);
+            if (realAbs !== realWorkspace && !realAbs.startsWith(`${realWorkspace}${path.sep}`)) {
+                return null;
+            }
+            const text = fs.readFileSync(absPath, "utf8");
+            if (from === undefined && lines === undefined) {
+                return { text, path: normalizedRelPath };
+            }
+            const split = text.split(/\r?\n/);
+            const start = Math.max((from ?? 1) - 1, 0);
+            const count = lines === undefined ? split.length - start : Math.max(lines, 0);
+            const slicedText = split.slice(start, start + count).join("\n");
+            return { text: slicedText, path: normalizedRelPath };
+        },
+        stats() {
+            const fileCount = fileCountStmt.get()?.count ?? 0;
+            const chunkCount = chunkCountStmt.get()?.count ?? 0;
+            const sources = sourceStatsStmt.all().map((row) => ({
+                source: row.source,
+                files: Number(row.files),
+                chunks: Number(row.chunks),
+            }));
+            return {
+                files: Number(fileCount),
+                chunks: Number(chunkCount),
+                sources,
+                dbPath,
+                vectorDims: vectorEnabled ? dimensions : 0,
+            };
+        },
+        close() {
+            if (db.open) {
+                db.close();
+            }
+        },
+    };
+}

package/dist/sync.d.ts

@@ -0,0 +1,31 @@
+import { type Chunk, type EmbeddingClient, type IndexManager, type MediaModality, type SyncOptions } from "./types.js";
+export interface SyncManager {
+    sync(opts?: SyncOptions): Promise<void>;
+    markDirty(): void;
+    isDirty(): boolean;
+    startWatching(opts?: {
+        debounceMs?: number;
+        intervalMinutes?: number;
+    }): void;
+    warmSession(sessionKey?: string): Promise<void>;
+    syncIfDirty(): void;
+    close(): void;
+}
+export declare function flattenSessionJsonl(content: string): {
+    text: string;
+    lineMap: number[];
+} | null;
+export declare function remapChunkLines(chunks: Chunk[], lineMap: number[]): void;
+export declare function createSyncManager(params: {
+    workspaceDir: string;
+    index: IndexManager;
+    embedding: EmbeddingClient;
+    chunkTokens: number;
+    chunkOverlap: number;
+    sessionsDir?: string;
+    multimodal?: {
+        enabled: boolean;
+        modalities: MediaModality[];
+        maxFileBytes?: number;
+    };
+}): SyncManager;