@gencode/agents 0.0.9 → 0.0.10

package/dist/memory/manager.js

@@ -1,1006 +0,0 @@
-import fs from "node:fs/promises";
-import fsSync from "node:fs";
-import path from "node:path";
-import { createMockEmbeddingProvider } from "./embeddings.js";
-import { resolveEmbeddingProvider } from "./embedding-registry.js";
-import { isFileMissingError, statRegularFile } from "./fs-utils.js";
-import { buildFileEntry, chunkMarkdown, ensureDir, hashText, isMemoryPath, listMemoryFiles, parseEmbedding, remapChunkLines, } from "./internal.js";
-import { bm25RankToScore, buildFtsQuery, mergeHybridResults } from "./hybrid.js";
-import { ensureMemoryIndexSchema } from "./memory-schema.js";
-import { searchKeyword, searchVector } from "./manager-search.js";
-import { requireNodeSqlite } from "./sqlite.js";
-import { DEFAULT_MEMORY_SEARCH_CONFIG } from "./config.js";
-import { loadSqliteVecExtension } from "./sqlite-vec.js";
-import { buildSessionEntry, listSessionFilesForAgent } from "./session-files.js";
-const SNIPPET_MAX_CHARS = 700;
-const VECTOR_TABLE = "chunks_vec";
-const FTS_TABLE = "chunks_fts";
-const EMBEDDING_CACHE_TABLE = "embedding_cache";
-const META_KEY = "memory_index_meta_v1";
-const VECTOR_LOAD_TIMEOUT_MS = 30_000;
-const MANAGER_CACHE = new Map();
-function resolveConfig(base, override) {
-    const config = {
-        ...base,
-        ...override,
-        hybrid: { ...base.hybrid, ...(override?.hybrid ?? {}) },
-        cache: { ...base.cache, ...(override?.cache ?? {}) },
-        sync: { ...base.sync, ...(override?.sync ?? {}) },
-        experimental: { ...base.experimental, ...(override?.experimental ?? {}) },
-        sources: override?.sources ?? base.sources,
-        embedding: { ...base.embedding, ...(override?.embedding ?? {}) },
-        store: {
-            ...base.store,
-            ...(override?.store ?? {}),
-            vector: { ...base.store.vector, ...(override?.store?.vector ?? {}) },
-        },
-    };
-    if (config.experimental.sessionMemory && !config.sources.includes("sessions")) {
-        config.sources = [...config.sources, "sessions"];
-    }
-    return config;
-}
-export class MemoryIndexManager {
-    dataDir;
-    memoryRoot;
-    storePath;
-    config;
-    provider;
-    providerKey;
-    embeddingProviderId;
-    db;
-    dirty = true;
-    ftsAvailable = false;
-    ftsError;
-    vector = {
-        enabled: true,
-        available: null,
-        extensionPath: undefined,
-        loadError: undefined,
-        dims: undefined,
-    };
-    vectorReady = null;
-    watchers = [];
-    watchTimer = null;
-    sessionWatchTimer = null;
-    sessionsDirty = false;
-    sessionsDirtyFiles = new Set();
-    sessionPendingFiles = new Set();
-    sessionDeltas = new Map();
-    static get(dataDir, config) {
-        const memoryRoot = path.join(dataDir, ".aimax");
-        const existing = MANAGER_CACHE.get(memoryRoot);
-        if (existing) {
-            if (config) {
-                existing.applyConfig(config);
-            }
-            return existing;
-        }
-        const manager = new MemoryIndexManager(dataDir, memoryRoot, config);
-        MANAGER_CACHE.set(memoryRoot, manager);
-        return manager;
-    }
-    constructor(dataDir, memoryRoot, config) {
-        this.dataDir = dataDir;
-        this.memoryRoot = memoryRoot;
-        this.storePath = path.join(memoryRoot, ".index.sqlite");
-        this.config = resolveConfig(DEFAULT_MEMORY_SEARCH_CONFIG, config);
-        this.provider = createMockEmbeddingProvider();
-        this.providerKey = this.computeProviderKey();
-        this.applyEmbeddingProvider();
-        this.vector.enabled = this.config.store.vector.enabled;
-        this.vector.extensionPath = this.config.store.vector.extensionPath;
-        this.db = this.openDatabase();
-        this.ensureSchema();
-        this.ensureWatcher();
-        this.ensureSessionListener();
-        this.dirty = true;
-    }
-    applyConfig(config) {
-        this.config = resolveConfig(this.config, config);
-        this.applyEmbeddingProvider();
-        this.vector.enabled = this.config.store.vector.enabled;
-        this.vector.extensionPath = this.config.store.vector.extensionPath;
-        this.ensureWatcher();
-        this.ensureSessionListener();
-    }
-    warmSession() {
-        if (!this.config.sync.onSessionStart) {
-            return;
-        }
-        void this.sync({ reason: "session-start" }).catch(() => { });
-    }
-    noteSessionUpdate(sessionFile) {
-        this.scheduleSessionDirty(sessionFile);
-    }
-    status() {
-        const sourceFilter = this.buildSourceFilter();
-        const files = this.db
-            .prepare(`SELECT COUNT(*) as c FROM files WHERE 1=1${sourceFilter.sql}`)
-            .get(...sourceFilter.params);
-        const chunks = this.db
-            .prepare(`SELECT COUNT(*) as c FROM chunks WHERE 1=1${sourceFilter.sql}`)
-            .get(...sourceFilter.params);
-        const sourceCounts = (() => {
-            const sources = Array.from(this.config.sources);
-            if (sources.length === 0) {
-                return [];
-            }
-            const bySource = new Map();
-            for (const source of sources) {
-                bySource.set(source, { files: 0, chunks: 0 });
-            }
-            const fileRows = this.db
-                .prepare(`SELECT source, COUNT(*) as c FROM files WHERE 1=1${sourceFilter.sql} GROUP BY source`)
-                .all(...sourceFilter.params);
-            for (const row of fileRows) {
-                const entry = bySource.get(row.source) ?? { files: 0, chunks: 0 };
-                entry.files = row.c ?? 0;
-                bySource.set(row.source, entry);
-            }
-            const chunkRows = this.db
-                .prepare(`SELECT source, COUNT(*) as c FROM chunks WHERE 1=1${sourceFilter.sql} GROUP BY source`)
-                .all(...sourceFilter.params);
-            for (const row of chunkRows) {
-                const entry = bySource.get(row.source) ?? { files: 0, chunks: 0 };
-                entry.chunks = row.c ?? 0;
-                bySource.set(row.source, entry);
-            }
-            return sources.map((source) => Object.assign({ source }, bySource.get(source)));
-        })();
-        const searchMode = this.provider ? "hybrid" : "fts-only";
-        const cacheEntries = this.config.cache.enabled
-            ? this.db.prepare(`SELECT COUNT(*) as c FROM ${EMBEDDING_CACHE_TABLE}`).get()?.c ?? 0
-            : undefined;
-        return {
-            backend: "builtin",
-            files: files?.c ?? 0,
-            chunks: chunks?.c ?? 0,
-            dirty: this.dirty || this.sessionsDirty,
-            workspaceDir: this.memoryRoot,
-            dbPath: this.storePath,
-            provider: this.provider.id,
-            model: this.provider.model,
-            sources: Array.from(this.config.sources),
-            sourceCounts,
-            cache: this.config.cache.enabled
-                ? { enabled: true, entries: cacheEntries, maxEntries: this.config.cache.maxEntries }
-                : { enabled: false, maxEntries: this.config.cache.maxEntries },
-            fts: {
-                enabled: this.config.hybrid.enabled,
-                available: this.ftsAvailable,
-                error: this.ftsError,
-            },
-            vector: {
-                enabled: this.vector.enabled,
-                available: this.vector.available ?? undefined,
-                extensionPath: this.vector.extensionPath,
-                loadError: this.vector.loadError,
-                dims: this.vector.dims,
-            },
-            custom: { searchMode },
-        };
-    }
-    async probeEmbeddingAvailability() {
-        try {
-            await this.provider.embedBatch(["ping"]);
-            return { ok: true };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return { ok: false, error: message };
-        }
-    }
-    async probeVectorAvailability() {
-        if (!this.vector.enabled) {
-            return false;
-        }
-        return await this.ensureVectorReady();
-    }
-    async search(query) {
-        const cleaned = query.trim();
-        if (!cleaned) {
-            return [];
-        }
-        const meta = this.readMeta();
-        if (!meta) {
-            await this.sync({ reason: "boot" });
-        }
-        else if (this.config.sync.onSearch && (this.dirty || this.sessionsDirty)) {
-            void this.sync({ reason: "search" }).catch(() => { });
-        }
-        const hybrid = this.config.hybrid;
-        const candidates = Math.min(200, Math.max(1, Math.floor(this.config.maxResults * hybrid.candidateMultiplier)));
-        const keywordResults = hybrid.enabled && this.ftsAvailable
-            ? await this.searchKeyword(cleaned, candidates).catch(() => [])
-            : [];
-        const queryVec = await this.provider.embedQuery(cleaned);
-        const hasVector = queryVec.some((v) => v !== 0);
-        const vectorResults = hasVector
-            ? await this.searchVector(queryVec, candidates).catch(() => [])
-            : [];
-        if (!hybrid.enabled || !this.ftsAvailable) {
-            return vectorResults
-                .filter((entry) => entry.score >= this.config.minScore)
-                .slice(0, this.config.maxResults);
-        }
-        const merged = await mergeHybridResults({
-            vector: vectorResults.map((r) => ({
-                id: `${r.path}:${r.startLine}:${r.endLine}:${r.source}`,
-                path: r.path,
-                startLine: r.startLine,
-                endLine: r.endLine,
-                source: r.source,
-                snippet: r.snippet,
-                vectorScore: r.score,
-            })),
-            keyword: keywordResults.map((r) => ({
-                id: `${r.path}:${r.startLine}:${r.endLine}:${r.source}`,
-                path: r.path,
-                startLine: r.startLine,
-                endLine: r.endLine,
-                source: r.source,
-                snippet: r.snippet,
-                textScore: r.textScore,
-            })),
-            vectorWeight: hybrid.vectorWeight,
-            textWeight: hybrid.textWeight,
-            mmr: hybrid.mmr,
-            temporalDecay: hybrid.temporalDecay,
-            memoryRoot: this.memoryRoot,
-        });
-        const strict = merged.filter((entry) => entry.score >= this.config.minScore);
-        if (strict.length > 0 || keywordResults.length === 0) {
-            return this.decorateCitations(strict.slice(0, this.config.maxResults));
-        }
-        const relaxedMinScore = Math.min(this.config.minScore, hybrid.textWeight);
-        const relaxedResults = merged
-            .filter((entry) => entry.score >= relaxedMinScore)
-            .slice(0, this.config.maxResults);
-        return this.decorateCitations(relaxedResults);
-    }
-    async readFile(params) {
-        const { absPath, relPath } = this.resolveMemoryFilePath(params.relPath);
-        const statResult = await statRegularFile(absPath);
-        if (statResult.missing) {
-            return { text: "", path: relPath };
-        }
-        let content;
-        try {
-            content = await fs.readFile(absPath, "utf-8");
-        }
-        catch (err) {
-            if (isFileMissingError(err)) {
-                return { text: "", path: relPath };
-            }
-            throw err;
-        }
-        if (!params.from && !params.lines) {
-            return { text: content, path: relPath };
-        }
-        const lines = content.split("\n");
-        const start = Math.max(1, params.from ?? 1);
-        const count = Math.max(1, params.lines ?? lines.length);
-        const slice = lines.slice(start - 1, start - 1 + count);
-        return { text: slice.join("\n"), path: relPath };
-    }
-    async replaceFile(params) {
-        const { absPath } = this.resolveMemoryFilePath(params.relPath);
-        await fs.mkdir(path.dirname(absPath), { recursive: true });
-        await fs.writeFile(absPath, params.content, "utf-8");
-        this.dirty = true;
-    }
-    async deleteFile(relPath) {
-        const { absPath } = this.resolveMemoryFilePath(relPath);
-        try {
-            await fs.unlink(absPath);
-        }
-        catch (err) {
-            if (isFileMissingError(err)) {
-                return;
-            }
-            throw err;
-        }
-        this.dirty = true;
-    }
-    async appendToMemory(content) {
-        const dir = this.memoryRoot;
-        await fs.mkdir(dir, { recursive: true });
-        const filePath = path.join(dir, "MEMORY.md");
-        const entry = content.endsWith("\n") ? content : `${content}\n`;
-        await fs.appendFile(filePath, entry, "utf-8");
-        this.dirty = true;
-    }
-    openDatabase() {
-        ensureDir(path.dirname(this.storePath));
-        const { DatabaseSync } = requireNodeSqlite();
-        return new DatabaseSync(this.storePath, { allowExtension: this.vector.enabled });
-    }
-    ensureSchema() {
-        const result = ensureMemoryIndexSchema({
-            db: this.db,
-            embeddingCacheTable: EMBEDDING_CACHE_TABLE,
-            ftsTable: FTS_TABLE,
-            ftsEnabled: this.config.hybrid.enabled,
-        });
-        this.ftsAvailable = result.ftsAvailable;
-        if (result.ftsError) {
-            this.ftsError = result.ftsError;
-        }
-    }
-    async ensureVectorReady(dimensions) {
-        if (!this.vector.enabled) {
-            return false;
-        }
-        if (!this.vectorReady) {
-            this.vectorReady = this.withTimeout(this.loadVectorExtension(), VECTOR_LOAD_TIMEOUT_MS, `sqlite-vec load timed out after ${Math.round(VECTOR_LOAD_TIMEOUT_MS / 1000)}s`);
-        }
-        let ready = false;
-        try {
-            ready = (await this.vectorReady) || false;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            this.vector.available = false;
-            this.vector.loadError = message;
-            this.vectorReady = null;
-            return false;
-        }
-        if (ready && typeof dimensions === "number" && dimensions > 0) {
-            this.ensureVectorTable(dimensions);
-        }
-        return ready;
-    }
-    async loadVectorExtension() {
-        if (this.vector.available !== null) {
-            return this.vector.available;
-        }
-        if (!this.vector.enabled) {
-            this.vector.available = false;
-            return false;
-        }
-        try {
-            const resolvedPath = this.vector.extensionPath?.trim()
-                ? this.vector.extensionPath.trim()
-                : undefined;
-            const loaded = await loadSqliteVecExtension({ db: this.db, extensionPath: resolvedPath });
-            if (!loaded.ok) {
-                throw new Error(loaded.error ?? "unknown sqlite-vec load error");
-            }
-            this.vector.extensionPath = loaded.extensionPath;
-            this.vector.available = true;
-            return true;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            this.vector.available = false;
-            this.vector.loadError = message;
-            return false;
-        }
-    }
-    ensureVectorTable(dimensions) {
-        if (this.vector.dims === dimensions) {
-            return;
-        }
-        if (this.vector.dims && this.vector.dims !== dimensions) {
-            this.dropVectorTable();
-        }
-        this.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${VECTOR_TABLE} USING vec0(\n` +
-            `  id TEXT PRIMARY KEY,\n` +
-            `  embedding FLOAT[${dimensions}]\n` +
-            `)`);
-        this.vector.dims = dimensions;
-    }
-    dropVectorTable() {
-        try {
-            this.db.exec(`DROP TABLE IF EXISTS ${VECTOR_TABLE}`);
-        }
-        catch { }
-    }
-    async withTimeout(promise, timeoutMs, message) {
-        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-            return await promise;
-        }
-        let timer = null;
-        const timeoutPromise = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-        });
-        try {
-            return (await Promise.race([promise, timeoutPromise]));
-        }
-        finally {
-            if (timer) {
-                clearTimeout(timer);
-            }
-        }
-    }
-    ensureWatcher() {
-        if (!this.config.sync.watch || this.watchers.length > 0) {
-            return;
-        }
-        const watchTargets = [
-            path.join(this.memoryRoot, "MEMORY.md"),
-            path.join(this.memoryRoot, "memory.md"),
-            path.join(this.memoryRoot, "memory"),
-        ];
-        const onChange = () => {
-            this.dirty = true;
-            this.scheduleWatchSync();
-        };
-        for (const target of watchTargets) {
-            try {
-                const watcher = fsSync.watch(target, { recursive: false }, onChange);
-                watcher.on("error", () => {
-                    try {
-                        watcher.close();
-                    }
-                    catch { }
-                });
-                this.watchers.push(watcher);
-            }
-            catch {
-                // Ignore missing/unwatchable paths.
-            }
-        }
-    }
-    scheduleWatchSync() {
-        if (!this.config.sync.watch) {
-            return;
-        }
-        if (this.watchTimer) {
-            clearTimeout(this.watchTimer);
-        }
-        this.watchTimer = setTimeout(() => {
-            this.watchTimer = null;
-            void this.sync({ reason: "watch" }).catch(() => { });
-        }, this.config.sync.watchDebounceMs);
-    }
-    ensureSessionListener() {
-        if (!this.config.experimental.sessionMemory) {
-            return;
-        }
-        const sessionsRoot = path.join(this.dataDir, ".aimax", "sessions");
-        try {
-            const watcher = fsSync.watch(sessionsRoot, { recursive: true }, (_event, filename) => {
-                if (!filename || !filename.endsWith("transcript.jsonl")) {
-                    return;
-                }
-                const abs = path.join(sessionsRoot, filename);
-                this.scheduleSessionDirty(abs);
-            });
-            this.watchers.push(watcher);
-        }
-        catch {
-            // Ignore missing/unwatchable sessions dir.
-        }
-    }
-    scheduleSessionDirty(sessionFile) {
-        if (!this.config.experimental.sessionMemory) {
-            return;
-        }
-        this.sessionPendingFiles.add(sessionFile);
-        if (this.sessionWatchTimer) {
-            return;
-        }
-        this.sessionWatchTimer = setTimeout(() => {
-            this.sessionWatchTimer = null;
-            void this.processSessionDeltaBatch().catch(() => { });
-        }, 5000);
-    }
-    async processSessionDeltaBatch() {
-        if (this.sessionPendingFiles.size === 0) {
-            return;
-        }
-        const pending = Array.from(this.sessionPendingFiles);
-        this.sessionPendingFiles.clear();
-        let shouldSync = false;
-        for (const sessionFile of pending) {
-            const delta = await this.updateSessionDelta(sessionFile);
-            if (!delta) {
-                continue;
-            }
-            const bytesThreshold = delta.deltaBytes;
-            const messagesThreshold = delta.deltaMessages;
-            const bytesHit = bytesThreshold <= 0 ? delta.pendingBytes > 0 : delta.pendingBytes >= bytesThreshold;
-            const messagesHit = messagesThreshold <= 0
-                ? delta.pendingMessages > 0
-                : delta.pendingMessages >= messagesThreshold;
-            if (!bytesHit && !messagesHit) {
-                continue;
-            }
-            this.sessionsDirtyFiles.add(sessionFile);
-            this.sessionsDirty = true;
-            delta.pendingBytes =
-                bytesThreshold > 0 ? Math.max(0, delta.pendingBytes - bytesThreshold) : 0;
-            delta.pendingMessages =
-                messagesThreshold > 0 ? Math.max(0, delta.pendingMessages - messagesThreshold) : 0;
-            shouldSync = true;
-        }
-        if (shouldSync) {
-            void this.sync({ reason: "session-delta" }).catch(() => { });
-        }
-    }
-    async updateSessionDelta(sessionFile) {
-        const thresholds = this.config.sync.sessions;
-        if (!thresholds) {
-            return null;
-        }
-        let stat;
-        try {
-            stat = await fs.stat(sessionFile);
-        }
-        catch {
-            return null;
-        }
-        const size = stat.size;
-        let state = this.sessionDeltas.get(sessionFile);
-        if (!state) {
-            state = { lastSize: 0, pendingBytes: 0, pendingMessages: 0 };
-            this.sessionDeltas.set(sessionFile, state);
-        }
-        const deltaBytes = Math.max(0, size - state.lastSize);
-        if (deltaBytes === 0 && size === state.lastSize) {
-            return {
-                deltaBytes: thresholds.deltaBytes,
-                deltaMessages: thresholds.deltaMessages,
-                pendingBytes: state.pendingBytes,
-                pendingMessages: state.pendingMessages,
-            };
-        }
-        if (size < state.lastSize) {
-            state.lastSize = size;
-            state.pendingBytes += size;
-            const shouldCountMessages = thresholds.deltaMessages > 0 &&
-                (thresholds.deltaBytes <= 0 || state.pendingBytes < thresholds.deltaBytes);
-            if (shouldCountMessages) {
-                state.pendingMessages += await this.countNewlines(sessionFile, 0, size);
-            }
-        }
-        else {
-            state.pendingBytes += deltaBytes;
-            const shouldCountMessages = thresholds.deltaMessages > 0 &&
-                (thresholds.deltaBytes <= 0 || state.pendingBytes < thresholds.deltaBytes);
-            if (shouldCountMessages) {
-                state.pendingMessages += await this.countNewlines(sessionFile, state.lastSize, size);
-            }
-            state.lastSize = size;
-        }
-        this.sessionDeltas.set(sessionFile, state);
-        return {
-            deltaBytes: thresholds.deltaBytes,
-            deltaMessages: thresholds.deltaMessages,
-            pendingBytes: state.pendingBytes,
-            pendingMessages: state.pendingMessages,
-        };
-    }
-    async countNewlines(absPath, start, end) {
-        if (end <= start) {
-            return 0;
-        }
-        let handle;
-        try {
-            handle = await fs.open(absPath, "r");
-        }
-        catch {
-            return 0;
-        }
-        try {
-            let offset = start;
-            let count = 0;
-            const buffer = Buffer.alloc(64 * 1024);
-            while (offset < end) {
-                const toRead = Math.min(buffer.length, end - offset);
-                const { bytesRead } = await handle.read(buffer, 0, toRead, offset);
-                if (bytesRead <= 0) {
-                    break;
-                }
-                for (let i = 0; i < bytesRead; i += 1) {
-                    if (buffer[i] === 10) {
-                        count += 1;
-                    }
-                }
-                offset += bytesRead;
-            }
-            return count;
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    computeProviderKey() {
-        return hashText(JSON.stringify({ provider: this.provider.id, model: this.provider.model }));
-    }
-    resolveMemoryFilePath(rawPath) {
-        const trimmed = rawPath.trim();
-        if (!trimmed) {
-            throw new Error("path required");
-        }
-        const absPath = path.isAbsolute(trimmed)
-            ? path.resolve(trimmed)
-            : path.resolve(this.memoryRoot, trimmed);
-        const relPath = path.relative(this.memoryRoot, absPath).replace(/\\/g, "/");
-        const inWorkspace = relPath.length > 0 && !relPath.startsWith("..") && !path.isAbsolute(relPath);
-        const allowed = inWorkspace && isMemoryPath(relPath);
-        if (!allowed) {
-            throw new Error("path required");
-        }
-        if (!absPath.endsWith(".md")) {
-            throw new Error("path required");
-        }
-        return { absPath, relPath };
-    }
-    applyEmbeddingProvider() {
-        const providerId = this.config.embedding?.providerId?.trim();
-        if (providerId) {
-            const resolved = resolveEmbeddingProvider({
-                providerId,
-                dataDir: this.dataDir,
-                memoryDir: this.memoryRoot,
-            });
-            if (!resolved) {
-                throw new Error(`Embedding provider not found: ${providerId}`);
-            }
-            this.provider = resolved.provider;
-            this.embeddingProviderId = providerId;
-            this.providerKey = this.computeProviderKey();
-            this.dirty = true;
-            return;
-        }
-        if (this.embeddingProviderId) {
-            this.provider = createMockEmbeddingProvider();
-            this.embeddingProviderId = undefined;
-            this.providerKey = this.computeProviderKey();
-            this.dirty = true;
-        }
-    }
-    readMeta() {
-        const row = this.db.prepare(`SELECT value FROM meta WHERE key = ?`).get(META_KEY);
-        if (!row?.value) {
-            return null;
-        }
-        try {
-            return JSON.parse(row.value);
-        }
-        catch {
-            return null;
-        }
-    }
-    writeMeta(meta) {
-        const value = JSON.stringify(meta);
-        this.db
-            .prepare(`INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`)
-            .run(META_KEY, value);
-    }
-    loadEmbeddingCache(hashes) {
-        if (!this.config.cache.enabled || hashes.length === 0) {
-            return new Map();
-        }
-        const unique = Array.from(new Set(hashes.filter(Boolean)));
-        if (unique.length === 0) {
-            return new Map();
-        }
-        const out = new Map();
-        const baseParams = [this.provider.id, this.provider.model, this.providerKey];
-        const batchSize = 400;
-        for (let start = 0; start < unique.length; start += batchSize) {
-            const batch = unique.slice(start, start + batchSize);
-            const placeholders = batch.map(() => "?").join(", ");
-            const rows = this.db
-                .prepare(`SELECT hash, embedding FROM ${EMBEDDING_CACHE_TABLE}\n` +
-                ` WHERE provider = ? AND model = ? AND provider_key = ? AND hash IN (${placeholders})`)
-                .all(...baseParams, ...batch);
-            for (const row of rows) {
-                out.set(row.hash, parseEmbedding(row.embedding));
-            }
-        }
-        return out;
-    }
-    upsertEmbeddingCache(entries) {
-        if (!this.config.cache.enabled || entries.length === 0) {
-            return;
-        }
-        const now = Date.now();
-        const stmt = this.db.prepare(`INSERT INTO ${EMBEDDING_CACHE_TABLE} (provider, model, provider_key, hash, embedding, dims, updated_at)\n` +
-            ` VALUES (?, ?, ?, ?, ?, ?, ?)\n` +
-            ` ON CONFLICT(provider, model, provider_key, hash) DO UPDATE SET\n` +
-            `   embedding=excluded.embedding,\n` +
-            `   dims=excluded.dims,\n` +
-            `   updated_at=excluded.updated_at`);
-        for (const entry of entries) {
-            const embedding = entry.embedding ?? [];
-            stmt.run(this.provider.id, this.provider.model, this.providerKey, entry.hash, JSON.stringify(embedding), embedding.length, now);
-        }
-    }
-    async embedChunks(chunks) {
-        if (chunks.length === 0) {
-            return [];
-        }
-        const cached = this.loadEmbeddingCache(chunks.map((chunk) => chunk.hash));
-        const embeddings = Array.from({ length: chunks.length }, () => []);
-        const missing = [];
-        for (let i = 0; i < chunks.length; i += 1) {
-            const chunk = chunks[i];
-            const hit = chunk?.hash ? cached.get(chunk.hash) : undefined;
-            if (hit && hit.length > 0) {
-                embeddings[i] = hit;
-            }
-            else if (chunk) {
-                missing.push({ index: i, chunk });
-            }
-        }
-        if (missing.length === 0) {
-            return embeddings;
-        }
-        const batchEmbeddings = await this.provider.embedBatch(missing.map((m) => m.chunk.text));
-        const toCache = [];
-        for (let i = 0; i < missing.length; i += 1) {
-            const item = missing[i];
-            const embedding = batchEmbeddings[i] ?? [];
-            embeddings[item.index] = embedding;
-            toCache.push({ hash: item.chunk.hash, embedding });
-        }
-        this.upsertEmbeddingCache(toCache);
-        return embeddings;
-    }
-    async indexFile(entry, options) {
-        const content = options.content ?? (await fs.readFile(entry.absPath, "utf-8"));
-        const chunks = chunkMarkdown(content, {
-            tokens: this.config.chunkTokens,
-            overlap: this.config.chunkOverlap,
-        }).filter((chunk) => chunk.text.trim().length > 0);
-        if (options.source === "sessions") {
-            remapChunkLines(chunks, options.lineMap);
-        }
-        const embeddings = await this.embedChunks(chunks);
-        const sample = embeddings.find((embedding) => embedding.length > 0);
-        const vectorReady = sample ? await this.ensureVectorReady(sample.length) : false;
-        const now = Date.now();
-        if (vectorReady) {
-            try {
-                this.db
-                    .prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`)
-                    .run(entry.path, options.source);
-            }
-            catch { }
-        }
-        if (this.ftsAvailable) {
-            try {
-                this.db
-                    .prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`)
-                    .run(entry.path, options.source, this.provider.model);
-            }
-            catch { }
-        }
-        this.db
-            .prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`)
-            .run(entry.path, options.source);
-        for (let i = 0; i < chunks.length; i += 1) {
-            const chunk = chunks[i];
-            const embedding = embeddings[i] ?? [];
-            const id = hashText(`${options.source}:${entry.path}:${chunk.startLine}:${chunk.endLine}:${chunk.hash}:${this.provider.model}`);
-            this.db
-                .prepare(`INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-           ON CONFLICT(id) DO UPDATE SET
-             hash=excluded.hash,
-             model=excluded.model,
-             text=excluded.text,
-             embedding=excluded.embedding,
-             updated_at=excluded.updated_at`)
-                .run(id, entry.path, options.source, chunk.startLine, chunk.endLine, chunk.hash, this.provider.model, chunk.text, JSON.stringify(embedding), now);
-            if (vectorReady && embedding.length > 0) {
-                try {
-                    this.db.prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id = ?`).run(id);
-                }
-                catch { }
-                this.db
-                    .prepare(`INSERT INTO ${VECTOR_TABLE} (id, embedding) VALUES (?, ?)`)
-                    .run(id, Buffer.from(new Float32Array(embedding).buffer));
-            }
-            if (this.ftsAvailable) {
-                this.db
-                    .prepare(`INSERT INTO ${FTS_TABLE} (text, id, path, source, model, start_line, end_line)\n` +
-                    ` VALUES (?, ?, ?, ?, ?, ?, ?)`)
-                    .run(chunk.text, id, entry.path, options.source, this.provider.model, chunk.startLine, chunk.endLine);
-            }
-        }
-        this.db
-            .prepare(`INSERT INTO files (path, source, hash, mtime, size) VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT(path) DO UPDATE SET
-           source=excluded.source,
-           hash=excluded.hash,
-           mtime=excluded.mtime,
-           size=excluded.size`)
-            .run(entry.path, options.source, entry.hash, entry.mtimeMs, entry.size);
-    }
-    buildSourceFilter() {
-        const sources = this.config.sources;
-        if (!sources.length) {
-            return { sql: "", params: [] };
-        }
-        const placeholders = sources.map(() => "?").join(", ");
-        return { sql: ` AND source IN (${placeholders})`, params: sources };
-    }
-    async searchVector(queryVec, limit) {
-        return await searchVector({
-            db: this.db,
-            vectorTable: VECTOR_TABLE,
-            providerModel: this.provider.model,
-            queryVec,
-            limit,
-            snippetMaxChars: SNIPPET_MAX_CHARS,
-            ensureVectorReady: async (dimensions) => await this.ensureVectorReady(dimensions),
-            sourceFilterVec: this.buildSourceFilter(),
-            sourceFilterChunks: this.buildSourceFilter(),
-        });
-    }
-    async searchKeyword(query, limit) {
-        if (!this.ftsAvailable) {
-            return [];
-        }
-        return await searchKeyword({
-            db: this.db,
-            ftsTable: FTS_TABLE,
-            providerModel: this.provider.model,
-            query,
-            limit,
-            snippetMaxChars: SNIPPET_MAX_CHARS,
-            sourceFilter: this.buildSourceFilter(),
-            buildFtsQuery: (raw) => buildFtsQuery(raw),
-            bm25RankToScore,
-        });
-    }
-    resetIndex() {
-        this.db.exec(`DELETE FROM files`);
-        this.db.exec(`DELETE FROM chunks`);
-        if (this.ftsAvailable) {
-            try {
-                this.db.exec(`DELETE FROM ${FTS_TABLE}`);
-            }
-            catch { }
-        }
-        this.dropVectorTable();
-        this.vector.dims = undefined;
-        this.sessionsDirtyFiles.clear();
-    }
-    async sync(params) {
-        const meta = this.readMeta();
-        const needsFullReindex = !meta ||
-            meta.model !== this.provider.model ||
-            meta.provider !== this.provider.id ||
-            meta.providerKey !== this.providerKey ||
-            meta.chunkTokens !== this.config.chunkTokens ||
-            meta.chunkOverlap !== this.config.chunkOverlap ||
-            (this.vector.available && !meta?.vectorDims);
-        if (needsFullReindex) {
-            this.resetIndex();
-        }
-        const files = await listMemoryFiles(this.memoryRoot);
-        const fileEntries = (await Promise.all(files.map(async (file) => buildFileEntry(file, this.memoryRoot)))).filter((entry) => entry !== null);
-        const activePaths = new Set(fileEntries.map((entry) => entry.path));
-        const tasks = fileEntries.map((entry) => async () => {
-            const record = this.db
-                .prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`)
-                .get(entry.path, "memory");
-            if (!needsFullReindex && record?.hash === entry.hash) {
-                return;
-            }
-            await this.indexFile(entry, { source: "memory" });
-        });
-        for (const task of tasks) {
-            await task();
-        }
-        const staleRows = this.db
-            .prepare(`SELECT path FROM files WHERE source = ?`)
-            .all("memory");
-        for (const stale of staleRows) {
-            if (activePaths.has(stale.path)) {
-                continue;
-            }
-            this.db.prepare(`DELETE FROM files WHERE path = ? AND source = ?`).run(stale.path, "memory");
-            try {
-                this.db
-                    .prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`)
-                    .run(stale.path, "memory");
-            }
-            catch { }
-            this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(stale.path, "memory");
-            if (this.ftsAvailable) {
-                try {
-                    this.db
-                        .prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`)
-                        .run(stale.path, "memory", this.provider.model);
-                }
-                catch { }
-            }
-        }
-        if (this.config.experimental.sessionMemory && (needsFullReindex || this.sessionsDirty)) {
-            await this.syncSessionFiles(needsFullReindex);
-        }
-        this.writeMeta({
-            model: this.provider.model,
-            provider: this.provider.id,
-            providerKey: this.providerKey,
-            chunkTokens: this.config.chunkTokens,
-            chunkOverlap: this.config.chunkOverlap,
-            ...(this.vector.available && this.vector.dims ? { vectorDims: this.vector.dims } : {}),
-        });
-        this.dirty = false;
-    }
-    async syncSessionFiles(needsFullReindex) {
-        const files = await listSessionFilesForAgent(this.dataDir);
-        const entries = (await Promise.all(files.map(async (absPath) => buildSessionEntry(this.dataDir, absPath)))).filter((entry) => entry !== null);
-        const activePaths = new Set(entries.map((entry) => entry.path));
-        const indexAll = needsFullReindex || this.sessionsDirtyFiles.size === 0;
-        for (const entry of entries) {
-            if (!indexAll && !this.sessionsDirtyFiles.has(entry.absPath)) {
-                continue;
-            }
-            const record = this.db
-                .prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`)
-                .get(entry.path, "sessions");
-            if (!needsFullReindex && record?.hash === entry.hash) {
-                this.resetSessionDelta(entry.absPath, entry.size);
-                continue;
-            }
-            await this.indexFile(entry, {
-                source: "sessions",
-                content: entry.content,
-                lineMap: entry.lineMap,
-            });
-            this.resetSessionDelta(entry.absPath, entry.size);
-        }
-        const staleRows = this.db
-            .prepare(`SELECT path FROM files WHERE source = ?`)
-            .all("sessions");
-        for (const stale of staleRows) {
-            if (activePaths.has(stale.path)) {
-                continue;
-            }
-            this.db
-                .prepare(`DELETE FROM files WHERE path = ? AND source = ?`)
-                .run(stale.path, "sessions");
-            try {
-                this.db
-                    .prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`)
-                    .run(stale.path, "sessions");
-            }
-            catch { }
-            this.db
-                .prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`)
-                .run(stale.path, "sessions");
-            if (this.ftsAvailable) {
-                try {
-                    this.db
-                        .prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`)
-                        .run(stale.path, "sessions", this.provider.model);
-                }
-                catch { }
-            }
-        }
-        this.sessionsDirty = false;
-        this.sessionsDirtyFiles.clear();
-    }
-    resetSessionDelta(absPath, size) {
-        const state = this.sessionDeltas.get(absPath);
-        if (!state) {
-            return;
-        }
-        state.lastSize = size;
-        state.pendingBytes = 0;
-        state.pendingMessages = 0;
-    }
-    decorateCitations(results) {
-        if (this.config.citations === "off") {
-            return results;
-        }
-        return results.map((entry) => {
-            const citation = `Source: ${entry.path}#L${entry.startLine}-L${entry.endLine}`;
-            if (this.config.citations === "on") {
-                return { ...entry, citation, snippet: `${entry.snippet}\n\n${citation}` };
-            }
-            return { ...entry, citation };
-        });
-    }
-}
-//# sourceMappingURL=manager.js.map