fix: migrate scoped memory columns before index creation

Author: newfish

src/main/sqliteStore.ts

@@ -118,11 +118,16 @@ export class SqliteStore {
     this.db.run(`
       CREATE TABLE IF NOT EXISTS user_memories (
         id TEXT PRIMARY KEY,
+        metabot_id INTEGER REFERENCES metabots(id),
         text TEXT NOT NULL,
         fingerprint TEXT NOT NULL,
         confidence REAL NOT NULL DEFAULT 0.75,
         is_explicit INTEGER NOT NULL DEFAULT 0,
         status TEXT NOT NULL DEFAULT 'created',
+        scope_kind TEXT NOT NULL DEFAULT 'owner',
+        scope_key TEXT NOT NULL DEFAULT 'owner:self',
+        usage_class TEXT NOT NULL DEFAULT 'profile_fact',
+        visibility TEXT NOT NULL DEFAULT 'local_only',
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL,
         last_used_at INTEGER
@@ -750,6 +755,30 @@ export class SqliteStore {
         }
         this.save();
       }
+      if (!umColumns.includes('scope_kind')) {
+        this.db.run("ALTER TABLE user_memories ADD COLUMN scope_kind TEXT NOT NULL DEFAULT 'owner';");
+      }
+      if (!umColumns.includes('scope_key')) {
+        this.db.run("ALTER TABLE user_memories ADD COLUMN scope_key TEXT NOT NULL DEFAULT 'owner:self';");
+      }
+      if (!umColumns.includes('usage_class')) {
+        this.db.run("ALTER TABLE user_memories ADD COLUMN usage_class TEXT NOT NULL DEFAULT 'profile_fact';");
+      }
+      if (!umColumns.includes('visibility')) {
+        this.db.run("ALTER TABLE user_memories ADD COLUMN visibility TEXT NOT NULL DEFAULT 'local_only';");
+      }
+      this.db.run(`
+        CREATE INDEX IF NOT EXISTS idx_user_memories_scope_status_updated
+        ON user_memories(metabot_id, scope_kind, scope_key, status, updated_at DESC)
+      `);
+      this.db.run(`
+        CREATE INDEX IF NOT EXISTS idx_user_memories_scope_fingerprint
+        ON user_memories(metabot_id, scope_kind, scope_key, fingerprint)
+      `);
+      this.db.run(`
+        CREATE INDEX IF NOT EXISTS idx_user_memories_usage_visibility
+        ON user_memories(metabot_id, usage_class, visibility, status, updated_at DESC)
+      `);
     } catch (error) {
       console.warn('Failed to migrate user_memories metabot_id:', error);
     }

tests/sqliteStoreMemoryScopeMigration.test.mjs

@@ -0,0 +1,106 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const initSqlJs = require('sql.js');
+const Module = require('node:module');
+const { DB_FILENAME } = require('../dist-electron/appConstants.js');
+
+const worktreeRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+const repoRoot = path.resolve(worktreeRoot, '..', '..');
+const sqlWasmPath = path.join(repoRoot, 'node_modules', 'sql.js', 'dist', 'sql-wasm.wasm');
+
+async function createSqlDatabase() {
+  const SQL = await initSqlJs({
+    locateFile: () => sqlWasmPath,
+  });
+  return new SQL.Database();
+}
+
+function getColumns(db, tableName) {
+  const result = db.exec(`PRAGMA table_info(${tableName})`);
+  return (result[0]?.values || []).map((row) => String(row[1]));
+}
+
+function getIndexNames(db, tableName) {
+  const result = db.exec(`PRAGMA index_list(${tableName})`);
+  return (result[0]?.values || []).map((row) => String(row[1]));
+}
+
+test('SqliteStore.create() upgrades legacy user_memories scope columns before creating scoped indexes', async () => {
+  const legacyDb = await createSqlDatabase();
+  legacyDb.run(`
+    CREATE TABLE kv (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+  legacyDb.run(`
+    CREATE TABLE metabots (
+      id INTEGER PRIMARY KEY,
+      name TEXT,
+      avatar TEXT,
+      metabot_type TEXT
+    );
+  `);
+  legacyDb.run(`
+    INSERT INTO metabots (id, name, avatar, metabot_type)
+    VALUES (1, 'Twin', NULL, 'twin');
+  `);
+  legacyDb.run(`
+    CREATE TABLE user_memories (
+      id TEXT PRIMARY KEY,
+      text TEXT NOT NULL,
+      fingerprint TEXT NOT NULL,
+      confidence REAL NOT NULL DEFAULT 0.75,
+      is_explicit INTEGER NOT NULL DEFAULT 0,
+      status TEXT NOT NULL DEFAULT 'created',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      last_used_at INTEGER
+    );
+  `);
+
+  const userDataPath = fs.mkdtempSync(path.join(os.tmpdir(), 'idbots-sqlitestore-memory-scope-'));
+  const dbPath = path.join(userDataPath, DB_FILENAME);
+  fs.writeFileSync(dbPath, Buffer.from(legacyDb.export()));
+
+  const originalLoad = Module._load;
+  Module._load = function patchedModuleLoad(request, parent, isMain) {
+    if (request === 'electron') {
+      return {
+        app: {
+          isPackaged: false,
+          getAppPath: () => repoRoot,
+          getPath: () => userDataPath,
+        },
+      };
+    }
+    return originalLoad(request, parent, isMain);
+  };
+
+  try {
+    const { SqliteStore } = require('../dist-electron/sqliteStore.js');
+    const sqliteStore = await SqliteStore.create(userDataPath);
+    const db = sqliteStore.getDatabase();
+
+    const columns = getColumns(db, 'user_memories');
+    assert(columns.includes('scope_kind'));
+    assert(columns.includes('scope_key'));
+    assert(columns.includes('usage_class'));
+    assert(columns.includes('visibility'));
+
+    const indexNames = getIndexNames(db, 'user_memories');
+    assert(indexNames.includes('idx_user_memories_scope_status_updated'));
+    assert(indexNames.includes('idx_user_memories_scope_fingerprint'));
+    assert(indexNames.includes('idx_user_memories_usage_visibility'));
+  } finally {
+    Module._load = originalLoad;
+    fs.rmSync(userDataPath, { recursive: true, force: true });
+  }
+});