opencode-fractal-memory 0.6.5 → 0.6.7

package/dist/management/helpers.js

@@ -4,11 +4,10 @@ import * as os from "node:os";
 import { Database } from "bun:sqlite";
 import { memLog } from "../logging";
 export const DB_PATHS = {};
-export function initDbPaths(projectDir) {
-    const globalDbPath = path.join(os.homedir(), ".config", "opencode", "memory.db");
-    const projectDbPath = path.join(projectDir, ".opencode", "memory.db");
-    DB_PATHS.global = globalDbPath;
-    DB_PATHS.project = projectDbPath;
+export function initDbPaths(_projectDir) {
+    const unifiedDbPath = path.join(os.homedir(), ".config", "opencode", "memory.db");
+    DB_PATHS.global = unifiedDbPath;
+    DB_PATHS.project = unifiedDbPath;
 }
 export function openDb(scope) {
     const dbPath = DB_PATHS[scope] || scope;
@@ -88,8 +87,9 @@ export function queryNodes(scope) {
            sticky, confidence, created_at, updated_at, parent_ids,
            LENGTH(content) as content_length, metadata
     FROM memory_nodes
+    WHERE scope = ?
     ORDER BY level, importance DESC
-  `).all();
+  `).all(scope);
     db.close();
     return rows.map((r) => rowToNode(r));
 }

package/dist/plugin/init.js

@@ -14,6 +14,9 @@ import { setHighContextThreshold, setCriticalContextThreshold, setMaxInjectionTo
 export async function initStorage(directory) {
     memLog("info", "init", "Creating memory store", { directory });
     const store = createMemoryStore(directory);
+    memLog("info", "init", "Migrating project DB to unified storage");
+    const migrated = await store.migrateFromProjectDb();
+    memLog("info", "init", "Project DB migration complete", { migrated });
     memLog("info", "init", "Ensuring seed nodes");
     await store.ensureSeed();
     memLog("info", "init", "Ensuring models");

package/dist/storage/lifecycle.js

@@ -2,15 +2,15 @@ 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) {
+export async function ensureSeed(getDb, seeds, projectName) {
     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);
+        const existing = db.query("SELECT id FROM memory_nodes WHERE label = ? AND scope = ?").get(seed.label, seed.scope);
         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]);
+            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, project_name) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [randomUUID(), seed.scope, seed.label, "", null, 0, null, null, now, now, 0.5, 0, null, "note", null, seed.scope === "project" ? projectName ?? null : null]);
         });
     }
 }

package/dist/storage/migrations/definitions.js

@@ -371,4 +371,26 @@ export const MIGRATIONS = [
             catch { /* column may already exist */ }
         },
     },
+    {
+        version: 21,
+        name: "add-project-name",
+        up: (db) => {
+            try {
+                db.run("ALTER TABLE memory_nodes ADD COLUMN project_name TEXT");
+            }
+            catch { /* column may already exist */ }
+            try {
+                db.run("ALTER TABLE bm25_index ADD COLUMN project_name TEXT");
+            }
+            catch { /* column may already exist */ }
+            try {
+                db.run("ALTER TABLE bm25_doc_stats ADD COLUMN project_name TEXT");
+            }
+            catch { /* column may already exist */ }
+            try {
+                db.run("ALTER TABLE playbooks ADD COLUMN project_name TEXT");
+            }
+            catch { /* column may already exist */ }
+        },
+    },
 ];

package/dist/storage/migrations/index.js

@@ -1,6 +1,6 @@
 import { MIGRATIONS } from "./definitions";
 export { MIGRATIONS } from "./definitions";
-export const CURRENT_VERSION = 20;
+export const CURRENT_VERSION = 21;
 export function getCurrentVersion(db) {
     const row = db.query("PRAGMA user_version").get();
     return row?.user_version ?? 0;

package/dist/storage/queries/base.js

@@ -40,5 +40,6 @@ export function rowToNode(row) {
         usefulnessScore: row.usefulness_score ?? 0,
         timesUsed: row.times_used ?? 0,
         timesHelpful: row.times_helpful ?? 0,
+        projectName: row.project_name ?? null,
     };
 }

package/dist/storage/queries/nodes.js

@@ -81,7 +81,7 @@ export async function queryCreateNode(db, node, storeLinks, updateLinksForNewNod
     const usefulnessScore = node.usefulnessScore ?? 0;
     const timesUsed = node.timesUsed ?? 0;
     const timesHelpful = node.timesHelpful ?? 0;
-    db.run("INSERT INTO memory_nodes (id, scope, label, content, summary, level, parent_ids, embedding, embedding_blob, created_at, updated_at, importance, access_count, last_accessed, type, metadata, sticky, ttl_days, expires_at, confidence, usefulness_score, times_used, times_helpful) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
+    db.run("INSERT INTO memory_nodes (id, scope, label, content, summary, level, parent_ids, embedding, embedding_blob, created_at, updated_at, importance, access_count, last_accessed, type, metadata, sticky, ttl_days, expires_at, confidence, usefulness_score, times_used, times_helpful, project_name) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
         id,
         node.scope,
         node.label ?? "",
@@ -105,6 +105,7 @@ export async function queryCreateNode(db, node, storeLinks, updateLinksForNewNod
         usefulnessScore,
         timesUsed,
         timesHelpful,
+        node.projectName ?? null,
     ]);
     // Store links
     await storeLinks(node.scope, id, node.content);
@@ -141,6 +142,7 @@ export async function queryCreateNode(db, node, storeLinks, updateLinksForNewNod
         usefulnessScore: node.usefulnessScore ?? 0,
         timesUsed: node.timesUsed ?? 0,
         timesHelpful: node.timesHelpful ?? 0,
+        projectName: node.projectName ?? null,
     };
 }
 const UPDATE_FIELDS = {

package/dist/storage/sqlite.js

@@ -1,4 +1,5 @@
 import * as fs from "node:fs/promises";
+import { existsSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { Database } from "bun:sqlite";
@@ -27,10 +28,8 @@ const SEED_BLOCKS = [
     { scope: "global", label: "human" },
     { scope: "project", label: "project" },
 ];
-function scopeDbPath(projectDirectory, scope, globalDbPath) {
-    return scope === "global"
-        ? (globalDbPath ?? path.join(os.homedir(), ".config", "opencode", "memory.db"))
-        : path.join(projectDirectory, ".opencode", "memory.db");
+function scopeDbPath(_projectDirectory, _scope, globalDbPath) {
+    return globalDbPath ?? path.join(os.homedir(), ".config", "opencode", "memory.db");
 }
 function validateLabel(label) {
     const trimmed = label.trim();
@@ -45,19 +44,21 @@ class SqliteMemoryStore {
     idScopeCache = new Map();
     projectDirectory;
     globalDbPath;
+    projectName;
     constructor(projectDirectory, globalDbPath) {
         this.projectDirectory = projectDirectory;
         this.globalDbPath = globalDbPath;
+        this.projectName = path.basename(projectDirectory);
     }
-    async getDb(scope) {
-        const key = `${scope}:${this.projectDirectory}:${this.globalDbPath ?? ""}`;
+    async getDb(_scope) {
+        const key = this.projectDirectory;
         if (this.dbs.has(key)) {
             return this.dbs.get(key);
         }
         const existing = this.dbInitPromises.get(key);
         if (existing)
             return existing;
-        const promise = this.initDb(key, scope);
+        const promise = this.initDb(key);
         this.dbInitPromises.set(key, promise);
         try {
             const db = await promise;
@@ -68,8 +69,8 @@ class SqliteMemoryStore {
             throw err;
         }
     }
-    async initDb(key, scope) {
-        const dbPath = scopeDbPath(this.projectDirectory, scope, this.globalDbPath);
+    async initDb(key) {
+        const dbPath = scopeDbPath(this.projectDirectory, "global", this.globalDbPath);
         const dbDir = path.dirname(dbPath);
         await fs.mkdir(dbDir, { recursive: true });
         const db = new Database(dbPath);
@@ -100,7 +101,55 @@ class SqliteMemoryStore {
         this.idScopeCache.clear();
     }
     async ensureSeed() {
-        return ensureSeedFn((s) => this.getDb(s), SEED_BLOCKS);
+        return ensureSeedFn((s) => this.getDb(s), SEED_BLOCKS, this.projectName);
+    }
+    async migrateFromProjectDb() {
+        const unifiedDb = await this.getDb();
+        const oldDbPath = path.join(this.projectDirectory, ".opencode", "memory.db");
+        if (!existsSync(oldDbPath))
+            return 0;
+        memLog("info", "storage", "Migrating project DB to unified storage", { path: oldDbPath, projectName: this.projectName });
+        const oldDb = new Database(oldDbPath);
+        let migrated = 0;
+        try {
+            const oldNodes = oldDb.query("SELECT * FROM memory_nodes").all();
+            for (const oldRow of oldNodes) {
+                const existing = unifiedDb.query("SELECT id FROM memory_nodes WHERE id = ?").get(oldRow.id);
+                if (existing)
+                    continue;
+                unifiedDb.run(`INSERT INTO memory_nodes (id, scope, label, content, summary, level, parent_ids, embedding, embedding_blob, created_at, updated_at, importance, access_count, last_accessed, type, metadata, sticky, ttl_days, expires_at, confidence, last_verified, usefulness_score, times_used, times_helpful, project_name)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    oldRow.id, oldRow.scope, oldRow.label, oldRow.content,
+                    oldRow.summary, oldRow.level, oldRow.parent_ids,
+                    oldRow.embedding, oldRow.embedding_blob,
+                    oldRow.created_at, oldRow.updated_at, oldRow.importance,
+                    oldRow.access_count, oldRow.last_accessed, oldRow.type,
+                    oldRow.metadata, oldRow.sticky ?? 0,
+                    oldRow.ttl_days, oldRow.expires_at,
+                    oldRow.confidence ?? 0.5, oldRow.last_verified,
+                    oldRow.usefulness_score ?? 0, oldRow.times_used ?? 0,
+                    oldRow.times_helpful ?? 0, this.projectName,
+                ]);
+                const bm25Rows = oldDb.query("SELECT * FROM bm25_index WHERE node_id = ?").all(oldRow.id);
+                for (const bm25 of bm25Rows) {
+                    unifiedDb.run("INSERT OR IGNORE INTO bm25_index (term, node_id, frequency, scope, project_name) VALUES (?, ?, ?, ?, ?)", [bm25.term, bm25.node_id, bm25.frequency, bm25.scope, this.projectName]);
+                }
+                const docStats = oldDb.query("SELECT * FROM bm25_doc_stats WHERE node_id = ?").get(oldRow.id);
+                if (docStats) {
+                    unifiedDb.run("INSERT OR IGNORE INTO bm25_doc_stats (node_id, token_count, scope, project_name) VALUES (?, ?, ?, ?)", [docStats.node_id, docStats.token_count, docStats.scope, this.projectName]);
+                }
+                migrated++;
+            }
+            const oldLinks = oldDb.query("SELECT * FROM memory_links").all();
+            for (const link of oldLinks) {
+                unifiedDb.run("INSERT OR IGNORE INTO memory_links (source_id, target_label, target_id) VALUES (?, ?, ?)", [link.source_id, link.target_label, link.target_id]);
+            }
+            memLog("info", "storage", "Project DB migration complete", { migrated });
+        }
+        finally {
+            oldDb.close();
+        }
+        return migrated;
     }
     async listNodes(scope, level, limit = 50, offset = 0, includeExpired) {
         const scopes = scope === "all" ? ["global", "project"] : [scope];
@@ -126,8 +175,11 @@ class SqliteMemoryStore {
     }
     async createNode(node) {
         const db = await this.getDb(node.scope);
+        const nodeWithProject = node.scope === "project" && !node.projectName
+            ? { ...node, projectName: this.projectName }
+            : node;
         return await withRetryableTransaction(db, async () => {
-            return await queryCreateNode(db, node, (scope, id, content) => this.storeLinks(scope, id, content), (scope, label, id) => this.updateLinksForNewNode(scope, label, id), (db, id, content, label, scope) => updateBM25Index(db, id, content, label, scope));
+            return await queryCreateNode(db, nodeWithProject, (scope, id, content) => this.storeLinks(scope, id, content), (scope, label, id) => this.updateLinksForNewNode(scope, label, id), (db, id, content, label, scope) => updateBM25Index(db, id, content, label, scope));
         });
     }
     async updateNode(id, updates) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-fractal-memory",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Fractal memory system for OpenCode with semantic search and automatic compression.",
   "main": "dist/plugin.js",
   "exports": {