opencode-fractal-memory 0.2.0

package/dist/storage/injection-events.js

@@ -0,0 +1,82 @@
+import { randomUUID } from "node:crypto";
+import { withRetry } from "./utils";
+export async function insertInjectionMetrics(db, sessionId, data) {
+    const id = randomUUID();
+    const timestamp = Date.now();
+    await withRetry(() => {
+        db.run(`INSERT INTO injection_metrics 
+       (id, session_id, timestamp, injected_node_count, injected_tokens, injection_mode, query_text, tool_calls, memory_tools_used, referenced_nodes)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 0, '[]', '[]')`, [id, sessionId, timestamp, data.injectedNodeCount, data.injectedTokens, data.injectionMode, data.queryText ?? null]);
+    });
+}
+export function getPendingInjections(db) {
+    try {
+        return db.query("SELECT id, node_id as nodeId, scope, source, created_at as createdAt FROM pending_injections WHERE processed = 0 ORDER BY id ASC").all();
+    }
+    catch {
+        return [];
+    }
+}
+export function markInjectionProcessed(db, id) {
+    try {
+        db.run("UPDATE pending_injections SET processed = 1 WHERE id = ?", [id]);
+    }
+    catch {
+        // silently ignore
+    }
+}
+export async function updateMemoryToolCall(db, sessionId, toolName) {
+    const metrics = db.query("SELECT id, tool_calls, memory_tools_used FROM injection_metrics WHERE session_id = ? ORDER BY timestamp DESC LIMIT 1").get(sessionId);
+    if (!metrics)
+        return;
+    const tools = JSON.parse(metrics.memory_tools_used || '[]');
+    if (!tools.includes(toolName)) {
+        tools.push(toolName);
+    }
+    await withRetry(() => {
+        db.run("UPDATE injection_metrics SET tool_calls = ?, memory_tools_used = ? WHERE id = ?", [metrics.tool_calls + 1, JSON.stringify(tools), metrics.id]);
+    });
+}
+export async function finalizeInjection(db, sessionId, effectivenessScore, taskDescription) {
+    await withRetry(() => {
+        db.run("UPDATE injection_metrics SET effectiveness_score = ?, task_description = ? WHERE session_id = ?", [effectivenessScore ?? null, taskDescription ?? null, sessionId]);
+    });
+}
+export async function insertInjectionFeedback(db, sessionId, upvotes, downvotes, taskOutcome, neededNodes) {
+    await withRetry(() => {
+        db.run(`UPDATE injection_metrics 
+       SET injection_upvotes = ?, injection_downvotes = ?, task_outcome = ?, needed_nodes = ?
+       WHERE session_id = ?`, [upvotes, downvotes, taskOutcome ?? null, neededNodes ? JSON.stringify(neededNodes) : null, sessionId]);
+    });
+}
+export function queryInjectionMetrics(db, limit = 100) {
+    const rows = db.query(`SELECT session_id, timestamp, injected_node_count, injected_tokens, injection_mode, tool_calls, effectiveness_score
+     FROM injection_metrics 
+     ORDER BY timestamp DESC 
+     LIMIT ?`).all(limit);
+    return rows.map(row => ({
+        sessionId: row.session_id,
+        timestamp: row.timestamp,
+        injectedNodeCount: row.injected_node_count,
+        injectedTokens: row.injected_tokens,
+        injectionMode: row.injection_mode,
+        toolCalls: row.tool_calls,
+        effectivenessScore: row.effectiveness_score,
+    }));
+}
+export function querySessionMetrics(db, sessionId) {
+    const row = db.query(`SELECT 
+       COUNT(*) as total_injections,
+       SUM(tool_calls) as total_tool_calls,
+       AVG(effectiveness_score) as avg_effectiveness
+     FROM injection_metrics 
+     WHERE session_id = ?`).get(sessionId);
+    const toolsRow = db.query(`SELECT memory_tools_used FROM injection_metrics WHERE session_id = ? LIMIT 1`).get(sessionId);
+    const memoryToolsUsed = toolsRow ? JSON.parse(toolsRow.memory_tools_used || '[]') : [];
+    return {
+        totalInjections: row.total_injections,
+        totalToolCalls: row.total_tool_calls ?? 0,
+        memoryToolsUsed,
+        avgEffectiveness: row.avg_effectiveness,
+    };
+}

package/dist/storage/lifecycle.js

@@ -0,0 +1,65 @@
+import { randomUUID } from "node:crypto";
+import { rowToNode } from "./queries/base";
+import { queryGetNode } from "./queries/nodes";
+import { withRetry } from "./utils";
+export async function ensureSeed(getDb, seeds) {
+    for (const seed of seeds) {
+        const db = await getDb(seed.scope);
+        const existing = db.query("SELECT id FROM memory_nodes WHERE label = ?").get(seed.label);
+        if (existing)
+            continue;
+        const now = Date.now();
+        await withRetry(() => {
+            db.run("INSERT INTO memory_nodes (id, scope, label, content, summary, level, parent_ids, embedding, created_at, updated_at, importance, access_count, last_accessed, type, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [randomUUID(), seed.scope, seed.label, "", null, 0, null, null, now, now, 0.5, 0, null, "note", null]);
+        });
+    }
+}
+export async function resolveNode(getDb, idScopeCache, id) {
+    if (idScopeCache.has(id)) {
+        const scope = idScopeCache.get(id);
+        return { scope, db: await getDb(scope) };
+    }
+    for (const scope of ["global", "project"]) {
+        const db = await getDb(scope);
+        const existing = db.query("SELECT id FROM memory_nodes WHERE id = ?").get(id);
+        if (existing) {
+            idScopeCache.set(id, scope);
+            return { scope, db };
+        }
+    }
+    throw new Error(`Memory node not found: ${id}`);
+}
+export async function getNode(getDb, id) {
+    let foundNode = null;
+    let foundScope = null;
+    for (const scope of ["global", "project"]) {
+        const node = await queryGetNode(await getDb(scope), id);
+        if (node) {
+            foundNode = node;
+            foundScope = scope;
+            break;
+        }
+    }
+    if (!foundNode || !foundScope) {
+        throw new Error(`Memory node not found: ${id}`);
+    }
+    const db = await getDb(foundScope);
+    const newAccessCount = foundNode.accessCount + 1;
+    const newConfidence = Math.min(1, foundNode.confidence + 0.01);
+    db.run("UPDATE memory_nodes SET access_count = ?, last_accessed = ?, confidence = ? WHERE id = ?", [newAccessCount, Date.now(), newConfidence, id]);
+    return { ...foundNode, accessCount: newAccessCount, confidence: newConfidence };
+}
+export async function verifyNode(getDb, id) {
+    for (const scope of ["global", "project"]) {
+        const db = await getDb(scope);
+        const existing = db.query("SELECT * FROM memory_nodes WHERE id = ?").get(id);
+        if (existing) {
+            const newConfidence = Math.min(1, (existing.confidence ?? 0.5) + 0.2);
+            await withRetry(() => {
+                db.run("UPDATE memory_nodes SET confidence = ?, last_verified = ? WHERE id = ?", [newConfidence, Date.now(), id]);
+            });
+            return rowToNode({ ...existing, confidence: newConfidence, last_verified: Date.now() });
+        }
+    }
+    throw new Error(`Memory node not found: ${id}`);
+}

package/dist/storage/maintenance.js

@@ -0,0 +1,60 @@
+import { getHNSWIndex } from "../hnsw-index";
+import { extractLinks, embeddingToBlob, blobToEmbedding, withRetry } from "./utils";
+import { updateBM25Index } from "./queries/search-helpers";
+export async function backfillLinks(db) {
+    const nodes = db.query("SELECT id, content FROM memory_nodes").all();
+    for (const node of nodes) {
+        const links = extractLinks(node.content);
+        if (links.length === 0)
+            continue;
+        await withRetry(() => {
+            db.run("DELETE FROM memory_links WHERE source_id = ?", [node.id]);
+        });
+        for (const label of links) {
+            let targetId = null;
+            try {
+                const target = db.query("SELECT id FROM memory_nodes WHERE label = ?").get(label);
+                targetId = target?.id ?? null;
+            }
+            catch { /* ignore */ }
+            await withRetry(() => {
+                db.run("INSERT OR REPLACE INTO memory_links (source_id, target_label, target_id) VALUES (?, ?, ?)", [node.id, label, targetId]);
+            });
+        }
+    }
+}
+export async function backfillBinaryEmbeddingsAndBM25(db, scope) {
+    const rows = db.query("SELECT id, label, content, embedding, embedding_blob FROM memory_nodes").all();
+    for (const row of rows) {
+        if (row.embedding && !row.embedding_blob) {
+            const embedding = JSON.parse(row.embedding);
+            const blob = embeddingToBlob(embedding);
+            await withRetry(() => {
+                db.run("UPDATE memory_nodes SET embedding_blob = ? WHERE id = ?", [blob, row.id]);
+            });
+        }
+        updateBM25Index(db, row.id, row.content, row.label, scope);
+    }
+}
+export async function rebuildHNSWIndex(getDb, scope) {
+    const hnsw = getHNSWIndex();
+    const nodes = [];
+    const scopes = scope === "all" || !scope ? ["global", "project"] : [scope];
+    for (const s of scopes) {
+        const db = await getDb(s);
+        const rows = db.query("SELECT id, embedding, embedding_blob FROM memory_nodes WHERE embedding IS NOT NULL OR embedding_blob IS NOT NULL").all();
+        for (const row of rows) {
+            let embedding = null;
+            if (row.embedding_blob) {
+                embedding = blobToEmbedding(row.embedding_blob);
+            }
+            else if (row.embedding) {
+                embedding = JSON.parse(row.embedding);
+            }
+            if (embedding) {
+                nodes.push({ id: row.id, embedding, scope: s });
+            }
+        }
+    }
+    await hnsw.rebuild(nodes);
+}

package/dist/storage/migrations/definitions.js

@@ -0,0 +1,374 @@
+export const MIGRATIONS = [
+    {
+        version: 1,
+        name: "create-table",
+        up: (db) => {
+            db.run(`
+        CREATE TABLE IF NOT EXISTS memory_nodes (
+          id TEXT PRIMARY KEY,
+          scope TEXT NOT NULL,
+          label TEXT NOT NULL,
+          content TEXT NOT NULL,
+          summary TEXT,
+          level INT NOT NULL DEFAULT 0,
+          parent_ids TEXT,
+          embedding TEXT,
+          created_at INT NOT NULL,
+          updated_at INT NOT NULL,
+          importance REAL DEFAULT 0.5,
+          access_count INT DEFAULT 0,
+          last_accessed INT,
+          type TEXT,
+          metadata TEXT
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_nodes_scope ON memory_nodes(scope)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_nodes_level ON memory_nodes(level)`);
+            try {
+                db.run(`CREATE INDEX IF NOT EXISTS idx_nodes_parent ON memory_nodes(parent_ids)`);
+            }
+            catch { /* index might already exist */ }
+        },
+    },
+    {
+        version: 2,
+        name: "add-parent-ids-embedding",
+        up: (db) => {
+            try {
+                const tableInfo = db.query("PRAGMA table_info(memory_nodes)").all();
+                const existingColumns = new Set(tableInfo.map(c => c.name));
+                if (existingColumns.size > 0) {
+                    if (!existingColumns.has("parent_ids")) {
+                        db.run("ALTER TABLE memory_nodes ADD COLUMN parent_ids TEXT");
+                    }
+                    if (!existingColumns.has("embedding")) {
+                        db.run("ALTER TABLE memory_nodes ADD COLUMN embedding TEXT");
+                    }
+                }
+            }
+            catch { /* table may not exist yet — v1 will create it */ }
+        },
+    },
+    {
+        version: 3,
+        name: "add-config-table",
+        up: (db) => {
+            db.run(`
+        CREATE TABLE IF NOT EXISTS memory_config (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL,
+          updated_at INT NOT NULL
+        )
+      `);
+            const now = Date.now();
+            db.run("INSERT OR IGNORE INTO memory_config (key, value, updated_at) VALUES (?, ?, ?)", ["context_threshold", "0.8", now]);
+            db.run("INSERT OR IGNORE INTO memory_config (key, value, updated_at) VALUES (?, ?, ?)", ["context_limit", "128000", now]);
+            db.run("INSERT OR IGNORE INTO memory_config (key, value, updated_at) VALUES (?, ?, ?)", ["similarity_threshold", "0.3", now]);
+        },
+    },
+    {
+        version: 5,
+        name: "add-usage-log-table",
+        up: (db) => {
+            db.run(`
+        CREATE TABLE IF NOT EXISTS memory_usage_log (
+          id TEXT PRIMARY KEY,
+          tool_name TEXT NOT NULL,
+          timestamp INT NOT NULL,
+          result_tokens INT DEFAULT 0,
+          context_warning INT DEFAULT 0,
+          success INT DEFAULT 1,
+          duration_ms INT DEFAULT 0
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_usage_log_tool ON memory_usage_log(tool_name)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_usage_log_ts ON memory_usage_log(timestamp)`);
+        },
+    },
+    {
+        version: 6,
+        name: "add-sticky-column",
+        up: (db) => {
+            try {
+                const tableInfo = db.query("PRAGMA table_info(memory_nodes)").all();
+                const existingColumns = new Set(tableInfo.map(c => c.name));
+                if (existingColumns.size > 0 && !existingColumns.has("sticky")) {
+                    db.run("ALTER TABLE memory_nodes ADD COLUMN sticky INT DEFAULT 0");
+                }
+            }
+            catch { /* table may not exist yet — v1 will create it */ }
+        },
+    },
+    {
+        version: 7,
+        name: "add-confidence-tracking",
+        up: (db) => {
+            try {
+                const tableInfo = db.query("PRAGMA table_info(memory_nodes)").all();
+                const existingColumns = new Set(tableInfo.map(c => c.name));
+                if (existingColumns.size > 0) {
+                    if (!existingColumns.has("confidence")) {
+                        db.run("ALTER TABLE memory_nodes ADD COLUMN confidence REAL DEFAULT 0.5");
+                    }
+                    if (!existingColumns.has("last_verified")) {
+                        db.run("ALTER TABLE memory_nodes ADD COLUMN last_verified INT");
+                    }
+                }
+            }
+            catch { /* table may not exist yet — v1 will create it */ }
+        },
+    },
+    {
+        version: 8,
+        name: "add-memory-links",
+        up: (db) => {
+            db.run(`
+        CREATE TABLE IF NOT EXISTS memory_links (
+          source_id TEXT NOT NULL,
+          target_label TEXT NOT NULL,
+          target_id TEXT,
+          PRIMARY KEY (source_id, target_label)
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_links_source ON memory_links(source_id)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_links_target ON memory_links(target_label)`);
+        },
+    },
+    {
+        version: 9,
+        name: "add-binary-embeddings-and-bm25-index",
+        up: (db) => {
+            try {
+                const tableInfo = db.query("PRAGMA table_info(memory_nodes)").all();
+                const existingColumns = new Set(tableInfo.map(c => c.name));
+                if (existingColumns.size > 0 && !existingColumns.has("embedding_blob")) {
+                    db.run("ALTER TABLE memory_nodes ADD COLUMN embedding_blob BLOB");
+                }
+            }
+            catch { /* table may not exist yet */ }
+            db.run(`
+        CREATE TABLE IF NOT EXISTS bm25_index (
+          term TEXT NOT NULL,
+          node_id TEXT NOT NULL,
+          frequency INT NOT NULL DEFAULT 1,
+          scope TEXT NOT NULL,
+          PRIMARY KEY (term, node_id)
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_bm25_term ON bm25_index(term)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_bm25_node ON bm25_index(node_id)`);
+            db.run(`
+        CREATE TABLE IF NOT EXISTS bm25_doc_stats (
+          node_id TEXT PRIMARY KEY,
+          token_count INT NOT NULL DEFAULT 0,
+          scope TEXT NOT NULL
+        )
+      `);
+        },
+    },
+    {
+        version: 10,
+        name: "add-injection-metrics",
+        up: (db) => {
+            db.run(`
+        CREATE TABLE IF NOT EXISTS injection_metrics (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          timestamp INT NOT NULL,
+          injected_node_count INT NOT NULL DEFAULT 0,
+          injected_tokens INT NOT NULL DEFAULT 0,
+          injection_mode TEXT,
+          query_text TEXT,
+          tool_calls INT NOT NULL DEFAULT 0,
+          memory_tools_used TEXT,
+          referenced_nodes TEXT,
+          effectiveness_score REAL,
+          task_description TEXT
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_injection_session ON injection_metrics(session_id)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_injection_ts ON injection_metrics(timestamp)`);
+        },
+    },
+    {
+        version: 12,
+        name: "add-tool-call-duration",
+        up: (db) => {
+            try {
+                db.run(`ALTER TABLE agent_tool_calls ADD COLUMN duration_ms REAL`);
+            }
+            catch (e) {
+                // Column may already exist
+            }
+        },
+    },
+    {
+        version: 13,
+        name: "add-injection-feedback",
+        up: (db) => {
+            try {
+                db.run(`ALTER TABLE injection_metrics ADD COLUMN injection_upvotes INT DEFAULT 0`);
+                db.run(`ALTER TABLE injection_metrics ADD COLUMN injection_downvotes INT DEFAULT 0`);
+                db.run(`ALTER TABLE injection_metrics ADD COLUMN task_outcome TEXT`);
+                db.run(`ALTER TABLE injection_metrics ADD COLUMN needed_nodes TEXT`);
+            }
+            catch (e) {
+                // Columns may already exist
+            }
+        },
+    },
+    {
+        version: 14,
+        name: "add-agent-tool-tracking",
+        up: (db) => {
+            db.run(`
+        CREATE TABLE IF NOT EXISTS agent_tool_calls (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          timestamp INT NOT NULL,
+          tool_name TEXT NOT NULL,
+          args_json TEXT,
+          output_preview TEXT,
+          success INTEGER,
+          duration_ms INTEGER,
+          tool_category TEXT,
+          file_path TEXT,
+          command TEXT
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_agent_tool_session ON agent_tool_calls(session_id)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_agent_tool_name ON agent_tool_calls(tool_name)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_agent_tool_ts ON agent_tool_calls(timestamp)`);
+            db.run(`
+        CREATE TABLE IF NOT EXISTS session_metrics (
+          session_id TEXT PRIMARY KEY,
+          started_at INT NOT NULL,
+          ended_at INT,
+          total_tool_calls INT DEFAULT 0,
+          file_reads INT DEFAULT 0,
+          file_edits INT DEFAULT 0,
+          bash_commands INT DEFAULT 0,
+          memory_tools INT DEFAULT 0,
+          failed_tools INT DEFAULT 0,
+          unique_files_touched TEXT,
+          injection_count INT DEFAULT 0,
+          injected_tokens INT DEFAULT 0,
+          task_description TEXT,
+          status TEXT DEFAULT 'active'
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_session_started ON session_metrics(started_at)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_session_status ON session_metrics(status)`);
+        },
+    },
+    {
+        version: 16,
+        name: "add-pending-injections",
+        up: (db) => {
+            db.run(`
+        CREATE TABLE IF NOT EXISTS pending_injections (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          node_id TEXT NOT NULL,
+          scope TEXT NOT NULL DEFAULT 'global',
+          source TEXT DEFAULT 'management',
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          processed INTEGER NOT NULL DEFAULT 0
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_pending_injections_processed ON pending_injections(processed)`);
+        },
+    },
+    {
+        version: 15,
+        name: "add-usefulness-scores",
+        up: (db) => {
+            try {
+                const tableInfo = db.query("PRAGMA table_info(memory_nodes)").all();
+                const existingColumns = new Set(tableInfo.map(c => c.name));
+                if (existingColumns.size > 0) {
+                    if (!existingColumns.has("usefulness_score")) {
+                        db.run("ALTER TABLE memory_nodes ADD COLUMN usefulness_score REAL DEFAULT 0");
+                    }
+                    if (!existingColumns.has("times_used")) {
+                        db.run("ALTER TABLE memory_nodes ADD COLUMN times_used INT DEFAULT 0");
+                    }
+                    if (!existingColumns.has("times_helpful")) {
+                        db.run("ALTER TABLE memory_nodes ADD COLUMN times_helpful INT DEFAULT 0");
+                    }
+                }
+            }
+            catch { /* table may not exist yet */ }
+        },
+    },
+    {
+        version: 17,
+        name: "add-composite-index",
+        up: (db) => {
+            db.run("CREATE INDEX IF NOT EXISTS idx_nodes_scope_level_importance_created ON memory_nodes(scope, level, importance DESC, created_at DESC)");
+        },
+    },
+    {
+        version: 18,
+        name: "add-playbooks",
+        up: (db) => {
+            db.run(`
+        CREATE TABLE IF NOT EXISTS playbooks (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          description TEXT NOT NULL,
+          scope TEXT NOT NULL DEFAULT 'project',
+          steps TEXT NOT NULL,
+          triggers TEXT NOT NULL DEFAULT '[]',
+          execution_count INT NOT NULL DEFAULT 0,
+          avg_duration_ms REAL,
+          last_executed_at INT,
+          created_at INT NOT NULL,
+          updated_at INT NOT NULL,
+          source_session_id TEXT,
+          tags TEXT NOT NULL DEFAULT '[]'
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_playbooks_scope ON playbooks(scope)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_playbooks_name ON playbooks(name)`);
+            db.run(`
+        CREATE TABLE IF NOT EXISTS playbook_steps (
+          id TEXT PRIMARY KEY,
+          playbook_id TEXT NOT NULL,
+          step_index INT NOT NULL,
+          tool_name TEXT NOT NULL,
+          description TEXT NOT NULL,
+          params TEXT NOT NULL DEFAULT '{}',
+          expected_outcome TEXT,
+          critical INT NOT NULL DEFAULT 0,
+          FOREIGN KEY (playbook_id) REFERENCES playbooks(id) ON DELETE CASCADE
+        )
+      `);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_playbook_steps_pb ON playbook_steps(playbook_id)`);
+            db.run(`CREATE INDEX IF NOT EXISTS idx_playbook_steps_tool ON playbook_steps(tool_name)`);
+        },
+    },
+    {
+        version: 19,
+        name: "add-ttl",
+        up: (db) => {
+            try {
+                db.run("ALTER TABLE memory_nodes ADD COLUMN ttl_days INT");
+            }
+            catch { /* column may already exist */ }
+            try {
+                db.run("ALTER TABLE memory_nodes ADD COLUMN expires_at INT");
+            }
+            catch { /* column may already exist */ }
+        },
+    },
+    {
+        version: 20,
+        name: "add-duration-ms",
+        up: (db) => {
+            try {
+                db.run("ALTER TABLE memory_usage_log ADD COLUMN duration_ms INT DEFAULT 0");
+            }
+            catch { /* column may already exist */ }
+        },
+    },
+];

package/dist/storage/migrations/index.js

@@ -0,0 +1,21 @@
+import { MIGRATIONS } from "./definitions";
+export { MIGRATIONS } from "./definitions";
+export const CURRENT_VERSION = 20;
+export function getCurrentVersion(db) {
+    const row = db.query("PRAGMA user_version").get();
+    return row?.user_version ?? 0;
+}
+export function runMigrations(db) {
+    for (const migration of MIGRATIONS) {
+        migration.up(db);
+    }
+    db.run(`PRAGMA user_version = ${CURRENT_VERSION}`);
+    return CURRENT_VERSION;
+}
+export function getConfig(db, key, defaultValue) {
+    const row = db.query("SELECT value FROM memory_config WHERE key = ?").get(key);
+    return row?.value ?? defaultValue;
+}
+export function setConfig(db, key, value) {
+    db.run("INSERT OR REPLACE INTO memory_config (key, value, updated_at) VALUES (?, ?, ?)", [key, value, Date.now()]);
+}