@kisev/memomatic 1.0.0-dev.46.gfbe1e4c6992e

package/dist/rules.js

@@ -0,0 +1,33 @@
+import { readFile } from "node:fs/promises";
+const NEVER_SAVE = /^-\s*never-save:\s*(.+?)\s*$/gim;
+const AUTO_CLEAN = /^-\s*auto-clean:\s*older-than=(\d+)d\s+scope=episodic\s*$/im;
+export const emptyRules = () => ({ neverSave: [], autoClean: null });
+export function parseRules(markdown) {
+    const rules = emptyRules();
+    for (const match of markdown.matchAll(NEVER_SAVE)) {
+        const topic = match[1].trim().toLowerCase();
+        if (topic)
+            rules.neverSave.push(topic);
+    }
+    const autoClean = AUTO_CLEAN.exec(markdown);
+    if (autoClean) {
+        const days = Number.parseInt(autoClean[1], 10);
+        if (Number.isFinite(days) && days > 0)
+            rules.autoClean = { olderThanDays: days, scope: "episodic" };
+    }
+    return rules;
+}
+export async function loadRules(rulesFile) {
+    try {
+        return parseRules(await readFile(rulesFile, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return emptyRules();
+        throw error;
+    }
+}
+export function isForbidden(text, rules) {
+    const lowered = text.toLowerCase();
+    return rules.neverSave.some((topic) => lowered.includes(topic));
+}

package/dist/search.d.ts

@@ -0,0 +1,13 @@
+import { type IndexedEntry, MemoryStore } from "./store.js";
+import type { MemomaticPaths } from "./paths.js";
+import type { MemomaticSettings } from "./settings.js";
+export type SearchHit = {
+    entry: IndexedEntry;
+    score: number;
+    snippet: string;
+};
+export declare function reindex(paths: MemomaticPaths, settings: MemomaticSettings, store: MemoryStore): Promise<number>;
+export declare function search(store: MemoryStore, query: string, settings: MemomaticSettings, options?: {
+    includeArchived?: boolean;
+    markSurfaced?: boolean;
+}): Promise<SearchHit[]>;

package/dist/search.js

@@ -0,0 +1,102 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { cosineSimilarity, stableIdFor } from "./store.js";
+import { entryKind, parseCorpusEntries } from "./corpus.js";
+import { entryImportance, entryObservedAt } from "./entries.js";
+import { embedTexts } from "./settings.js";
+async function corpusFiles(paths) {
+    const files = [];
+    for (const name of ["MEMORY.md", "USER.md"]) {
+        const file = join(paths.stateRoot, name);
+        if (await readFile(file, "utf8").then(() => true, () => false))
+            files.push(file);
+    }
+    for (const name of (await readdir(paths.dailyDir).catch(() => [])).sort()) {
+        if (name.endsWith(".md"))
+            files.push(join(paths.dailyDir, name));
+    }
+    return files;
+}
+export async function reindex(paths, settings, store) {
+    const entries = [];
+    for (const file of await corpusFiles(paths)) {
+        const markdown = await readFile(file, "utf8");
+        for (const entry of parseCorpusEntries(markdown, file)) {
+            if (entry.annotations.status === "superseded")
+                continue;
+            entries.push({
+                stableId: stableIdFor(file, entry.text, entry.annotations.key ?? null),
+                file: entry.file,
+                line: entry.line,
+                kind: entryKind(file),
+                key: entry.annotations.key ?? null,
+                text: entry.text,
+                trigger: entry.annotations.trigger ?? [],
+                importance: entryImportance(entry),
+                pinned: entry.annotations.pinned === true,
+                project: entry.annotations.project ?? null,
+                origin: entry.annotations.origin ?? null,
+                observedAt: Number.isNaN(entryObservedAt(entry)) ? null : entryObservedAt(entry),
+                status: entry.annotations.status === "active" ? "active" : null,
+            });
+        }
+    }
+    store.replaceEntries(entries);
+    const vectors = await embedTexts(settings, entries.map((entry) => entry.text)).catch(() => null);
+    if (vectors)
+        for (let index = 0; index < entries.length; index += 1) {
+            if (vectors[index].length)
+                store.setVector(entries[index].stableId, vectors[index]);
+        }
+    return entries.length;
+}
+function recencyMultiplier(entry, halfLifeDays, now = Date.now()) {
+    if (entry.kind !== "episodic" || entry.pinned)
+        return 1;
+    if (!entry.observedAt)
+        return 0.5;
+    const ageDays = Math.max(0, (now - entry.observedAt) / 86_400_000);
+    return Math.pow(0.5, ageDays / halfLifeDays);
+}
+function importanceMultiplier(entry) {
+    return 1 + (entry.importance - 5) * 0.06;
+}
+export async function search(store, query, settings, options = {}) {
+    const keyword = store.ftsSearch(query, 200);
+    const vector = new Map();
+    const queryVector = (await embedTexts(settings, [query]).catch(() => null))?.[0];
+    if (queryVector?.length) {
+        for (const row of store.vectors()) {
+            const similarity = cosineSimilarity(queryVector, row.data);
+            if (similarity > 0.05)
+                vector.set(row.stableId, similarity);
+        }
+    }
+    const candidates = new Set([...keyword.keys(), ...vector.keys()]);
+    const entries = store.allEntries().filter((item) => item.status === null);
+    const byId = new Map(entries.map((entry) => [entry.stableId, entry]));
+    const hits = [];
+    for (const stableId of candidates) {
+        const entry = byId.get(stableId);
+        if (!entry)
+            continue;
+        const keywordScore = keyword.get(stableId) ?? 0;
+        const vectorScore = vector.get(stableId) ?? 0;
+        const hybrid = vectorScore
+            ? keywordScore
+                ? 0.65 * vectorScore + 0.35 * keywordScore
+                : vectorScore
+            : keywordScore;
+        if (hybrid <= 0)
+            continue;
+        const score = hybrid * recencyMultiplier(entry, settings.search.halfLifeDays) * importanceMultiplier(entry);
+        if (score < settings.search.minScore)
+            continue;
+        hits.push({ entry, score, snippet: entry.text.slice(0, 240) });
+    }
+    hits.sort((left, right) => right.score - left.score);
+    const limited = hits.slice(0, settings.search.maxResults);
+    if (options.markSurfaced !== false && limited.length)
+        store.markSurfaced(limited.map((hit) => hit.entry.stableId), query);
+    return limited;
+}

package/dist/service.d.ts

@@ -0,0 +1,35 @@
+import { type MemoryRules } from "./rules.js";
+import { type MemomaticPaths } from "./paths.js";
+import { type MemomaticSettings } from "./settings.js";
+import { type SearchHit } from "./search.js";
+import { MemoryStore } from "./store.js";
+export type WriteRequest = {
+    text: string;
+    key?: string;
+    trigger?: string[];
+    importance?: number;
+    project?: string;
+    origin?: "user" | "agent";
+    target?: "episodic" | "curated" | "user";
+    pinned?: boolean;
+};
+export type MemomaticContext = {
+    paths: MemomaticPaths;
+    settings: MemomaticSettings;
+    rules: MemoryRules;
+    store: MemoryStore;
+};
+export declare function openMemomatic(): Promise<MemomaticContext>;
+export declare function writeEntry(context: MemomaticContext, request: WriteRequest): Promise<string>;
+export declare function searchMemory(context: MemomaticContext, query: string): Promise<SearchHit[]>;
+export declare function getEntry(context: MemomaticContext, file: string, line?: number): Promise<{
+    file: string;
+    line: number;
+    content: string;
+}>;
+export declare function forgetEntry(context: MemomaticContext, target: {
+    file: string;
+    line: number;
+}): Promise<string>;
+export declare function archiveOldEpisodic(context: MemomaticContext): Promise<string[]>;
+export declare function rebuildIndex(context: MemomaticContext): Promise<number>;

package/dist/service.js

@@ -0,0 +1,105 @@
+import { entryLine } from "./entries.js";
+import { appendDailyEntry, archiveFile, readTextIfExists, replaceEntryLine } from "./corpus.js";
+import { isForbidden, loadRules } from "./rules.js";
+import { memomaticPaths } from "./paths.js";
+import { loadSettings } from "./settings.js";
+import { reindex, search } from "./search.js";
+import { MemoryStore } from "./store.js";
+export async function openMemomatic() {
+    const paths = memomaticPaths();
+    const [settings, rules, store] = await Promise.all([
+        loadSettings(paths.settingsFile),
+        loadRules(paths.rulesFile),
+        MemoryStore.open(paths.indexFile),
+    ]);
+    return { paths, settings, rules, store };
+}
+export async function writeEntry(context, request) {
+    const text = request.text.trim();
+    if (!text)
+        throw new Error("memory text is empty");
+    if (isForbidden(text, context.rules))
+        throw new Error("memory text matches a never-save rule in MEMORY_RULES.md");
+    const origin = request.origin ?? "agent";
+    const observed = new Date().toISOString().slice(0, 10);
+    const line = entryLine(text, {
+        key: request.key,
+        status: origin === "user" && request.target === "user" ? "active" : undefined,
+        origin,
+        observed,
+        project: request.project,
+        importance: request.importance,
+        trigger: request.trigger,
+        pinned: request.pinned,
+    });
+    if (request.target === "curated" || request.target === "user") {
+        if (origin !== "user")
+            throw new Error("curated and user entries require origin=user");
+        const file = request.target === "user" ? context.paths.userFile : context.paths.memoryFile;
+        const current = (await readTextIfExists(file)) ?? "";
+        const next = `${current.trimEnd()}\n${line}\n`;
+        const { writeCorpusFile } = await import("./corpus.js");
+        await writeCorpusFile(context.paths, file, next);
+        return file;
+    }
+    return appendDailyEntry(context.paths, line);
+}
+export async function searchMemory(context, query) {
+    return search(context.store, query, context.settings);
+}
+export async function getEntry(context, file, line) {
+    const target = file.startsWith("/")
+        ? file
+        : `${context.paths.stateRoot}/${file.replace(/^\/+/, "")}`;
+    if (!target.startsWith(context.paths.stateRoot))
+        throw new Error("path escapes memomatic state root");
+    const content = await readTextIfExists(target);
+    if (content === undefined)
+        throw new Error(`memory file not found: ${file}`);
+    if (line === undefined)
+        return { file: target, line: 0, content };
+    const lines = content.split("\n");
+    if (line < 1 || line > lines.length)
+        throw new Error("line is out of range");
+    context.store.markUseful(context.store
+        .allEntries()
+        .filter((entry) => entry.file === target && entry.line === line)
+        .map((entry) => entry.stableId));
+    return { file: target, line, content: lines[line - 1] };
+}
+export async function forgetEntry(context, target) {
+    const file = target.file.startsWith("/")
+        ? target.file
+        : `${context.paths.stateRoot}/${target.file.replace(/^\/+/, "")}`;
+    if (!file.startsWith(context.paths.stateRoot))
+        throw new Error("path escapes memomatic state root");
+    const content = await readTextIfExists(file);
+    if (content === undefined)
+        throw new Error(`memory file not found: ${target.file}`);
+    const lines = content.split("\n");
+    if (target.line < 1 || target.line > lines.length)
+        throw new Error("line is out of range");
+    await replaceEntryLine(context.paths, file, target.line, null);
+    return file;
+}
+export async function archiveOldEpisodic(context) {
+    const archived = [];
+    if (!context.rules.autoClean)
+        return archived;
+    const cutoff = Date.now() - context.rules.autoClean.olderThanDays * 86_400_000;
+    for (const entry of context.store.allEntries()) {
+        if (entry.kind !== "episodic" || !entry.observedAt || entry.observedAt >= cutoff)
+            continue;
+        if (entry.pinned)
+            continue;
+        const alreadyDone = archived.includes(entry.file);
+        if (!alreadyDone) {
+            await archiveFile(context.paths, entry.file);
+            archived.push(entry.file);
+        }
+    }
+    return archived;
+}
+export async function rebuildIndex(context) {
+    return reindex(context.paths, context.settings, context.store);
+}

package/dist/settings.d.ts

@@ -0,0 +1,29 @@
+export type MemomaticSettings = {
+    embedding: {
+        url: string;
+        model: string;
+    } | null;
+    dream: {
+        model: string | null;
+        variant: string | null;
+        minScore: number;
+        minUseful: number;
+        minUniqueQueries: number;
+        maxCandidates: number;
+        memoryBudgetLines: number;
+        maxPriorEntryLoss: number;
+    };
+    search: {
+        maxResults: number;
+        minScore: number;
+        halfLifeDays: number;
+    };
+    archive: {
+        enabled: boolean;
+        days: number;
+    };
+};
+export declare const defaultSettings: () => MemomaticSettings;
+export declare function normalizeSettings(raw: unknown): MemomaticSettings;
+export declare function loadSettings(settingsFile: string): Promise<MemomaticSettings>;
+export declare function embedTexts(settings: MemomaticSettings, texts: string[]): Promise<Float32Array[] | null>;

package/dist/settings.js

@@ -0,0 +1,72 @@
+import { readFile } from "node:fs/promises";
+export const defaultSettings = () => ({
+    embedding: null,
+    dream: {
+        model: null,
+        variant: null,
+        minScore: 0.45,
+        minUseful: 2,
+        minUniqueQueries: 2,
+        maxCandidates: 12,
+        memoryBudgetLines: 80,
+        maxPriorEntryLoss: 0.25,
+    },
+    search: { maxResults: 6, minScore: 0.35, halfLifeDays: 30 },
+    archive: { enabled: false, days: 60 },
+});
+function mergeSection(base, override) {
+    if (!override || typeof override !== "object")
+        return base;
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (key in base && value !== null && value !== undefined)
+            merged[key] = value;
+    }
+    return merged;
+}
+export function normalizeSettings(raw) {
+    const defaults = defaultSettings();
+    const source = (raw ?? {});
+    const embedding = source.embedding;
+    return {
+        embedding: embedding && typeof embedding.url === "string" && typeof embedding.model === "string"
+            ? { url: embedding.url, model: embedding.model }
+            : null,
+        dream: mergeSection(defaults.dream, source.dream),
+        search: mergeSection(defaults.search, source.search),
+        archive: mergeSection(defaults.archive, source.archive),
+    };
+}
+export async function loadSettings(settingsFile) {
+    try {
+        return normalizeSettings(JSON.parse(await readFile(settingsFile, "utf8")));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return defaultSettings();
+        throw error;
+    }
+}
+export async function embedTexts(settings, texts) {
+    if (!settings.embedding || !texts.length)
+        return null;
+    const response = await fetch(settings.embedding.url, {
+        body: JSON.stringify({ input: texts, model: settings.embedding.model }),
+        headers: { "content-type": "application/json" },
+        method: "POST",
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!response.ok)
+        throw new Error(`embedding request failed: ${response.status} ${await response.text()}`);
+    const payload = (await response.json());
+    const list = payload.data ?? [];
+    if (list.length !== texts.length)
+        throw new Error("embedding response is incomplete");
+    const byIndex = new Map();
+    for (const item of list) {
+        if (!Array.isArray(item.embedding))
+            throw new Error("embedding response is malformed");
+        byIndex.set(item.index ?? byIndex.size, item.embedding);
+    }
+    return texts.map((_, index) => Float32Array.from(byIndex.get(index) ?? []));
+}

package/dist/store.d.ts

@@ -0,0 +1,49 @@
+import { DatabaseSync } from "node:sqlite";
+export type EntryKind = "curated" | "user" | "episodic";
+export type IndexedEntry = {
+    stableId: string;
+    file: string;
+    line: number;
+    kind: EntryKind;
+    key: string | null;
+    text: string;
+    trigger: string[];
+    importance: number;
+    pinned: boolean;
+    project: string | null;
+    origin: "user" | "agent" | null;
+    observedAt: number | null;
+    status: "active" | null;
+};
+export type VectorRow = {
+    stableId: string;
+    dim: number;
+    data: Float32Array;
+};
+export declare function stableIdFor(file: string, text: string, key: string | null): string;
+export declare class MemoryStore {
+    readonly db: DatabaseSync;
+    private readonly fts;
+    private constructor();
+    static open(indexFile: string): Promise<MemoryStore>;
+    private ensureFts;
+    hasFts(): boolean;
+    replaceEntries(entries: IndexedEntry[]): void;
+    allEntries(): IndexedEntry[];
+    ftsSearch(query: string, limit: number): Map<string, number>;
+    markSurfaced(stableIds: string[], query: string, now?: number): void;
+    markUseful(stableIds: string[], now?: number): void;
+    usageFor(stableId: string): {
+        surfaced: number;
+        useful: number;
+        queries: string[];
+        days: string[];
+        lastUsefulAt: number | null;
+    };
+    setVector(stableId: string, vector: Float32Array): void;
+    vectors(): VectorRow[];
+    getMeta(key: string): string | null;
+    setMeta(key: string, value: string): void;
+    close(): void;
+}
+export declare function cosineSimilarity(left: Float32Array, right: Float32Array): number;

package/dist/store.js

@@ -0,0 +1,221 @@
+import { createHash } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+export function stableIdFor(file, text, key) {
+    if (key)
+        return `key:${key}`;
+    return `sha:${createHash("sha256").update(`${file}\n${text}`).digest("hex").slice(0, 24)}`;
+}
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS entries (
+  stable_id TEXT PRIMARY KEY,
+  file TEXT NOT NULL,
+  line INTEGER NOT NULL,
+  kind TEXT NOT NULL,
+  key TEXT,
+  text TEXT NOT NULL,
+  trigger_phrases TEXT NOT NULL DEFAULT '[]',
+  importance INTEGER NOT NULL DEFAULT 5,
+  pinned INTEGER NOT NULL DEFAULT 0,
+  project TEXT,
+  origin TEXT,
+  observed_at INTEGER,
+  status TEXT
+);
+CREATE TABLE IF NOT EXISTS usage (
+  stable_id TEXT PRIMARY KEY,
+  surfaced INTEGER NOT NULL DEFAULT 0,
+  useful INTEGER NOT NULL DEFAULT 0,
+  queries TEXT NOT NULL DEFAULT '[]',
+  days TEXT NOT NULL DEFAULT '[]',
+  last_useful_at INTEGER
+);
+CREATE TABLE IF NOT EXISTS vectors (
+  stable_id TEXT PRIMARY KEY,
+  dim INTEGER NOT NULL,
+  data BLOB NOT NULL
+);
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+`;
+export class MemoryStore {
+    db;
+    fts;
+    constructor(indexFile) {
+        this.db = new DatabaseSync(indexFile);
+        this.db.exec("PRAGMA journal_mode = WAL;");
+        this.db.exec(SCHEMA);
+        this.fts = this.ensureFts();
+    }
+    static async open(indexFile) {
+        await mkdir(dirname(indexFile), { mode: 0o700, recursive: true });
+        return new MemoryStore(indexFile);
+    }
+    ensureFts() {
+        try {
+            this.db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(stable_id UNINDEXED, text);");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    hasFts() {
+        return this.fts;
+    }
+    replaceEntries(entries) {
+        this.db.exec("BEGIN IMMEDIATE;");
+        try {
+            this.db.exec("DELETE FROM entries;");
+            if (this.fts)
+                this.db.exec("DELETE FROM entries_fts;");
+            const seen = new Set();
+            for (const entry of entries) {
+                if (seen.has(entry.stableId))
+                    continue;
+                seen.add(entry.stableId);
+                this.db
+                    .prepare(`INSERT INTO entries (stable_id, file, line, kind, key, text, trigger_phrases, importance, pinned, project, origin, observed_at, status)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                    .run(entry.stableId, entry.file, entry.line, entry.kind, entry.key, entry.text, JSON.stringify(entry.trigger), entry.importance, entry.pinned ? 1 : 0, entry.project, entry.origin, entry.observedAt, entry.status);
+                if (this.fts)
+                    this.db
+                        .prepare("INSERT INTO entries_fts (stable_id, text) VALUES (?, ?);")
+                        .run(entry.stableId, entry.text);
+            }
+            this.db.exec("DELETE FROM usage WHERE stable_id NOT IN (SELECT stable_id FROM entries);");
+            this.db.exec("DELETE FROM vectors WHERE stable_id NOT IN (SELECT stable_id FROM entries);");
+            this.db.exec("COMMIT;");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK;");
+            throw error;
+        }
+    }
+    allEntries() {
+        return this.db
+            .prepare("SELECT stable_id, file, line, kind, key, text, trigger_phrases, importance, pinned, project, origin, observed_at, status FROM entries ORDER BY observed_at ASC")
+            .all()
+            .map((row) => {
+            const value = row;
+            return {
+                stableId: value.stable_id,
+                file: value.file,
+                line: value.line,
+                kind: value.kind,
+                key: value.key ?? null,
+                text: value.text,
+                trigger: JSON.parse(value.trigger_phrases),
+                importance: value.importance,
+                pinned: value.pinned === 1,
+                project: value.project ?? null,
+                origin: value.origin ?? null,
+                observedAt: value.observed_at ?? null,
+                status: value.status ?? null,
+            };
+        });
+    }
+    ftsSearch(query, limit) {
+        if (!this.fts)
+            return new Map();
+        const tokens = query
+            .toLowerCase()
+            .split(/[^\p{L}\p{N}]+/u)
+            .filter((token) => token.length >= 2)
+            .slice(0, 12);
+        if (!tokens.length)
+            return new Map();
+        const pattern = tokens.map((token) => `"${token.replace(/"/g, "")}"*`).join(" OR ");
+        const rows = this.db
+            .prepare(`SELECT stable_id, rank FROM entries_fts WHERE entries_fts MATCH ? ORDER BY rank LIMIT ?;`)
+            .all(pattern, limit);
+        const result = new Map();
+        for (const row of rows) {
+            const quality = -row.rank;
+            const score = quality <= 0 ? 0.1 : Math.min(1, 0.5 + quality * 0.25);
+            result.set(row.stable_id, score);
+        }
+        return result;
+    }
+    markSurfaced(stableIds, query, now = Date.now()) {
+        const queryHash = createHash("sha256").update(query.toLowerCase()).digest("hex").slice(0, 16);
+        const day = new Date(now).toISOString().slice(0, 10);
+        const read = this.db.prepare("SELECT queries, days FROM usage WHERE stable_id = ?;");
+        const upsert = this.db.prepare(`INSERT INTO usage (stable_id, surfaced, useful, queries, days) VALUES (?, 1, 0, ?, ?)
+      ON CONFLICT(stable_id) DO UPDATE SET
+        surfaced = usage.surfaced + 1,
+        queries = excluded.queries,
+        days = excluded.days;`);
+        for (const stableId of stableIds) {
+            const row = read.get(stableId);
+            const queries = row ? JSON.parse(row.queries) : [];
+            const days = row ? JSON.parse(row.days) : [];
+            if (!queries.includes(queryHash) && queries.length < 32)
+                queries.push(queryHash);
+            if (!days.includes(day))
+                days.push(day);
+            upsert.run(stableId, JSON.stringify(queries), JSON.stringify(days));
+        }
+    }
+    markUseful(stableIds, now = Date.now()) {
+        const statement = this.db.prepare(`INSERT INTO usage (stable_id, useful, last_useful_at) VALUES (?, 1, ?)
+      ON CONFLICT(stable_id) DO UPDATE SET useful = useful + 1, last_useful_at = ?;`);
+        for (const stableId of stableIds)
+            statement.run(stableId, now, now);
+    }
+    usageFor(stableId) {
+        const row = this.db.prepare("SELECT * FROM usage WHERE stable_id = ?").get(stableId);
+        if (!row)
+            return { surfaced: 0, useful: 0, queries: [], days: [], lastUsefulAt: null };
+        return {
+            surfaced: row.surfaced,
+            useful: row.useful,
+            queries: JSON.parse(row.queries),
+            days: JSON.parse(row.days),
+            lastUsefulAt: row.last_useful_at ?? null,
+        };
+    }
+    setVector(stableId, vector) {
+        this.db
+            .prepare(`INSERT INTO vectors (stable_id, dim, data) VALUES (?, ?, ?)
+        ON CONFLICT(stable_id) DO UPDATE SET dim = excluded.dim, data = excluded.data;`)
+            .run(stableId, vector.length, Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength));
+    }
+    vectors() {
+        return this.db.prepare("SELECT stable_id, dim, data FROM vectors").all().map((row) => ({
+            stableId: row.stable_id,
+            dim: row.dim,
+            data: new Float32Array(row.data.buffer.slice(row.data.byteOffset, row.data.byteOffset + row.data.byteLength)),
+        }));
+    }
+    getMeta(key) {
+        const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+        return row?.value ?? null;
+    }
+    setMeta(key, value) {
+        this.db
+            .prepare(`INSERT INTO meta (key, value) VALUES (?, ?)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value;`)
+            .run(key, value);
+    }
+    close() {
+        this.db.close();
+    }
+}
+export function cosineSimilarity(left, right) {
+    const length = Math.min(left.length, right.length);
+    let dot = 0;
+    let leftNorm = 0;
+    let rightNorm = 0;
+    for (let index = 0; index < length; index += 1) {
+        dot += left[index] * right[index];
+        leftNorm += left[index] * left[index];
+        rightNorm += right[index] * right[index];
+    }
+    if (!leftNorm || !rightNorm)
+        return 0;
+    return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}