opencode-fractal-memory 0.2.0

package/dist/management/helpers.js

@@ -0,0 +1,227 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+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 openDb(scope) {
+    const dbPath = DB_PATHS[scope] || scope;
+    if (!Bun.file(dbPath).exists())
+        return null;
+    const db = Database.open(dbPath);
+    db.run("PRAGMA journal_mode=WAL");
+    db.run("PRAGMA busy_timeout=5000");
+    return db;
+}
+export async function withDb(dbOrScope, fn) {
+    const db = typeof dbOrScope === "string" ? openDb(dbOrScope) : dbOrScope;
+    if (!db)
+        throw new Error("Database not found");
+    try {
+        return await fn(db);
+    }
+    finally {
+        if (typeof dbOrScope === "string")
+            db.close();
+    }
+}
+export const MIME_TYPES = {
+    ".html": "text/html",
+    ".js": "application/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+};
+export function serveFile(filePath) {
+    try {
+        const ext = path.extname(filePath);
+        const mimeType = MIME_TYPES[ext] || "application/octet-stream";
+        const body = Bun.file(filePath);
+        return new Response(body, { headers: { "Content-Type": mimeType } });
+    }
+    catch {
+        return new Response("Not found", { status: 404 });
+    }
+}
+export function jsonResponse(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+export function rowToNode(r) {
+    return {
+        id: r.id,
+        label: r.label || "",
+        content: r.content,
+        summary: r.summary,
+        level: r.level,
+        type: r.type,
+        importance: r.importance,
+        usefulnessScore: r.usefulness_score,
+        timesUsed: r.times_used,
+        timesHelpful: r.times_helpful,
+        accessCount: r.access_count,
+        sticky: !!r.sticky,
+        confidence: r.confidence,
+        createdAt: r.created_at,
+        updatedAt: r.updated_at,
+        parentIds: r.parent_ids ? JSON.parse(r.parent_ids) : null,
+        contentLength: r.content_length,
+        metadata: r.metadata ? JSON.parse(r.metadata) : null,
+    };
+}
+export function queryNodes(scope) {
+    const db = openDb(scope);
+    if (!db)
+        return [];
+    const rows = db.query(`
+    SELECT id, label, content, summary, level, type, importance,
+           usefulness_score, times_used, times_helpful, access_count,
+           sticky, confidence, created_at, updated_at, parent_ids,
+           LENGTH(content) as content_length, metadata
+    FROM memory_nodes
+    ORDER BY level, importance DESC
+  `).all();
+    db.close();
+    return rows.map((r) => rowToNode(r));
+}
+export function cosineSimilarity(a, b) {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length && i < b.length; i++) {
+        const ai = a[i] ?? 0;
+        const bi = b[i] ?? 0;
+        dot += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB) + 1e-8);
+}
+export function extractLinks(nodes) {
+    const links = [];
+    const nodeMap = new Map(nodes.map(n => [n.id, n]));
+    const seen = new Set();
+    for (const node of nodes) {
+        if (node.parentIds) {
+            for (const parentId of node.parentIds) {
+                if (nodeMap.has(parentId)) {
+                    const key = `${node.id}-${parentId}-parent`;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        links.push({ source: node.id, target: parentId, type: "parent" });
+                    }
+                }
+            }
+        }
+        const wikiLinkRegex = /\[\[([^\]]+)\]\]/g;
+        let match;
+        while ((match = wikiLinkRegex.exec(node.content)) !== null) {
+            const targetLabel = match[1];
+            const target = nodes.find(n => n.label === targetLabel);
+            if (target && target.id !== node.id) {
+                const key = `${node.id}-${target.id}-link`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    links.push({ source: node.id, target: target.id, type: "link" });
+                }
+            }
+        }
+    }
+    return links;
+}
+export function getAvailableScopes() {
+    return Object.entries(DB_PATHS)
+        .filter(([_, p]) => Bun.file(p).exists())
+        .map(([k, v]) => ({ scope: k, path: v }));
+}
+export const TYPE_SHAPES = {
+    note: "sphere",
+    event: "box",
+    episode: "box",
+    concept: "octahedron",
+    summary: "octahedron",
+    core: "dodecahedron",
+    improvement: "sphere",
+    howto: "sphere",
+    skill: "icosahedron",
+    unknown: "sphere",
+};
+export const CUSTOM_TYPE_SHAPES = {
+    "middle-term": "torus",
+};
+export function resolveNodeShape(node) {
+    const customType = node.metadata?.customType;
+    if (customType && CUSTOM_TYPE_SHAPES[customType]) {
+        return CUSTOM_TYPE_SHAPES[customType];
+    }
+    return TYPE_SHAPES[node.type] ?? "sphere";
+}
+export function computeStats(nodes) {
+    const nodesPerLevel = {};
+    const nodesPerType = {};
+    const nodesPerCustomType = {};
+    const nodesPerShape = {};
+    let totalImportance = 0;
+    let totalUsefulness = 0;
+    let totalAccessCount = 0;
+    let stickyCount = 0;
+    for (const node of nodes) {
+        nodesPerLevel[node.level] = (nodesPerLevel[node.level] ?? 0) + 1;
+        const typeKey = node.type || "unknown";
+        nodesPerType[typeKey] = (nodesPerType[typeKey] ?? 0) + 1;
+        const customType = node.metadata?.customType;
+        if (customType) {
+            nodesPerCustomType[customType] = (nodesPerCustomType[customType] ?? 0) + 1;
+        }
+        const shape = resolveNodeShape(node);
+        nodesPerShape[shape] = (nodesPerShape[shape] ?? 0) + 1;
+        totalImportance += node.importance;
+        totalUsefulness += node.usefulnessScore;
+        totalAccessCount += node.accessCount;
+        if (node.sticky)
+            stickyCount++;
+    }
+    const n = nodes.length || 1;
+    return {
+        totalNodes: nodes.length,
+        nodesPerLevel,
+        nodesPerType,
+        nodesPerCustomType,
+        nodesPerShape,
+        avgImportance: Math.round((totalImportance / n) * 100) / 100,
+        avgUsefulness: Math.round((totalUsefulness / n) * 100) / 100,
+        totalAccessCount,
+        stickyCount,
+    };
+}
+export function readProjectConfig() {
+    const configPath = path.join(os.homedir(), ".config", "opencode", "opencode-mem.json");
+    try {
+        if (fs.existsSync(configPath)) {
+            const raw = fs.readFileSync(configPath, "utf-8");
+            return JSON.parse(raw);
+        }
+    }
+    catch { }
+    return {};
+}
+export function writeProjectConfig(config) {
+    const configPath = path.join(os.homedir(), ".config", "opencode", "opencode-mem.json");
+    try {
+        const merged = { ...config };
+        fs.writeFileSync(configPath, JSON.stringify(merged, null, 2));
+        memLog("info", "config", "[config] Saved to:", { configPath });
+        return "ok";
+    }
+    catch (e) {
+        memLog("error", "config", "[config] Write error:", { error: e instanceof Error ? e.message : e });
+        return String(e);
+    }
+}

package/dist/management/router.js

@@ -0,0 +1,48 @@
+import { memLog } from "../logging";
+import { jsonResponse } from "./helpers";
+export class Router {
+    routes = [];
+    get(pattern, handler) {
+        this.routes.push({ method: "GET", pattern, handler });
+    }
+    post(pattern, handler) {
+        this.routes.push({ method: "POST", pattern, handler });
+    }
+    put(pattern, handler) {
+        this.routes.push({ method: "PUT", pattern, handler });
+    }
+    delete(pattern, handler) {
+        this.routes.push({ method: "DELETE", pattern, handler });
+    }
+    patch(pattern, handler) {
+        this.routes.push({ method: "PATCH", pattern, handler });
+    }
+    any(pattern, handler) {
+        this.routes.push({ method: null, pattern, handler });
+    }
+    async handle(req) {
+        const url = new URL(req.url);
+        const pathname = url.pathname;
+        for (const route of this.routes) {
+            if (route.method !== null && route.method !== req.method)
+                continue;
+            const match = pathname.match(route.pattern);
+            if (!match)
+                continue;
+            const ctx = {
+                params: match.groups ?? {},
+                scope: url.searchParams.get("scope") || "project",
+                url,
+                pathname,
+            };
+            try {
+                return await route.handler(req, ctx);
+            }
+            catch (err) {
+                memLog("error", "management", `[api] ${req.method} ${pathname}:`, { error: err instanceof Error ? err.message : err });
+                return jsonResponse({ error: err instanceof Error ? err.message : String(err) }, 500);
+            }
+        }
+        return null;
+    }
+}

package/dist/management/routes.js

@@ -0,0 +1,197 @@
+import { memLog } from "../logging";
+import { generateEmbedding } from "../embeddings";
+import { queryNodes, getAvailableScopes, extractLinks, computeStats, readProjectConfig, writeProjectConfig, rowToNode, withDb, jsonResponse, cosineSimilarity, } from "./helpers";
+function handleScopes() {
+    return jsonResponse(getAvailableScopes());
+}
+function handleNodes(ctx) {
+    return jsonResponse(queryNodes(ctx.scope));
+}
+function handleLinks(ctx) {
+    const nodes = queryNodes(ctx.scope);
+    return jsonResponse(extractLinks(nodes));
+}
+function handleStats(ctx) {
+    const nodes = queryNodes(ctx.scope);
+    return jsonResponse(computeStats(nodes));
+}
+function handleConfigGet() {
+    return jsonResponse(readProjectConfig());
+}
+async function handleConfigSave(req) {
+    const body = await req.text();
+    memLog("debug", "api", "[api] Received body:", { body });
+    const newConfig = JSON.parse(body);
+    const error = writeProjectConfig(newConfig);
+    return jsonResponse({ success: error === "ok", error: error === "ok" ? null : error });
+}
+async function handleInject(req) {
+    const body = await req.json();
+    if (!body.nodeId)
+        return jsonResponse({ success: false, error: "Missing nodeId" }, 400);
+    const nodeId = body.nodeId;
+    const injectScope = body.scope || "global";
+    return withDb(injectScope, async (db) => {
+        const exists = db.query("SELECT id FROM memory_nodes WHERE id = ?").get(nodeId);
+        if (!exists)
+            return jsonResponse({ success: false, error: "Node not found" }, 404);
+        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("INSERT INTO pending_injections (node_id, scope, source) VALUES (?, ?, 'management')", [nodeId, injectScope]);
+        memLog("info", "management", `[api] Queued node ${nodeId} for injection`);
+        return jsonResponse({ success: true });
+    });
+}
+async function handleSearch(ctx) {
+    const q = ctx.url.searchParams.get("q") || "";
+    const mode = ctx.url.searchParams.get("mode") || "text";
+    if (!q.trim())
+        return jsonResponse([]);
+    return withDb(ctx.scope, async (db) => {
+        if (mode === "text") {
+            const rows = db.query(`
+        SELECT id, label, content, summary, level, type, importance,
+               usefulness_score, times_used, times_helpful, access_count,
+               sticky, confidence, created_at, updated_at, parent_ids,
+               LENGTH(content) as content_length, metadata
+        FROM memory_nodes
+        WHERE label LIKE ? OR content LIKE ?
+        ORDER BY importance DESC
+        LIMIT 100
+      `).all(`%${q}%`, `%${q}%`);
+            return jsonResponse(rows.map(r => ({ ...rowToNode(r), score: r.importance })));
+        }
+        if (mode === "embedding") {
+            const queryEmbedding = await generateEmbedding(q);
+            const rows = db.query(`
+        SELECT id, label, content, summary, level, type, importance,
+               usefulness_score, times_used, times_helpful, access_count,
+               sticky, confidence, created_at, updated_at, parent_ids,
+               LENGTH(content) as content_length, metadata, embedding_blob
+        FROM memory_nodes
+        WHERE embedding_blob IS NOT NULL
+      `).all();
+            const results = rows.map(r => {
+                const floats = new Float32Array(r.embedding_blob.buffer, r.embedding_blob.byteOffset, r.embedding_blob.byteLength / 4);
+                const embedding = Array.from(floats);
+                return { ...rowToNode(r), score: cosineSimilarity(queryEmbedding, embedding) };
+            });
+            results.sort((a, b) => b.score - a.score);
+            return jsonResponse(results.slice(0, 50));
+        }
+        if (mode === "bm25") {
+            const terms = q.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter(t => t.length >= 2);
+            if (terms.length === 0)
+                return jsonResponse([]);
+            const placeholders = terms.map(() => "?").join(",");
+            const rows = db.query(`
+        SELECT n.id, n.label, n.content, n.summary, n.level, n.type, n.importance,
+               n.usefulness_score, n.times_used, n.times_helpful, n.access_count,
+               n.sticky, n.confidence, n.created_at, n.updated_at, n.parent_ids,
+               LENGTH(n.content) as content_length, n.metadata,
+               COALESCE(SUM(b.frequency), 0) as bm25_score
+        FROM memory_nodes n
+        INNER JOIN bm25_index b ON n.id = b.node_id
+        WHERE b.term IN (${placeholders})
+        GROUP BY n.id
+        ORDER BY bm25_score DESC
+        LIMIT 100
+      `).all(...terms);
+            return jsonResponse(rows.map(r => ({ ...rowToNode(r), score: r.bm25_score })));
+        }
+        return jsonResponse([]);
+    });
+}
+async function handleNodeUpdate(req, ctx) {
+    const nodeId = ctx.params.id;
+    const body = await req.json();
+    return withDb(ctx.scope, async (db) => {
+        const existing = db.query("SELECT content, label FROM memory_nodes WHERE id = ?").get(nodeId);
+        if (!existing)
+            return jsonResponse({ success: false, error: "Node not found" }, 404);
+        const newContent = body.content ?? existing.content;
+        let embeddingBuffer = null;
+        if (body.content !== undefined && body.content !== existing.content) {
+            memLog("info", "management", `[api] Regenerating embedding for node ${nodeId}`);
+            const embedding = await generateEmbedding(newContent);
+            embeddingBuffer = Buffer.from(new Float32Array(embedding).buffer);
+        }
+        const fields = [];
+        const values = [];
+        if (body.label !== undefined) {
+            fields.push("label = ?");
+            values.push(String(body.label));
+        }
+        if (body.content !== undefined) {
+            fields.push("content = ?");
+            values.push(newContent);
+        }
+        if (body.summary !== undefined) {
+            fields.push("summary = ?");
+            values.push(String(body.summary));
+        }
+        if (body.level !== undefined) {
+            fields.push("level = ?");
+            values.push(Number(body.level));
+        }
+        if (body.importance !== undefined) {
+            fields.push("importance = ?");
+            values.push(Number(body.importance));
+        }
+        if (body.type !== undefined) {
+            fields.push("type = ?");
+            values.push(String(body.type));
+        }
+        if (body.sticky !== undefined) {
+            fields.push("sticky = ?");
+            values.push(body.sticky ? 1 : 0);
+        }
+        if (body.confidence !== undefined) {
+            fields.push("confidence = ?");
+            values.push(Number(body.confidence));
+        }
+        if (body.usefulnessScore !== undefined) {
+            fields.push("usefulness_score = ?");
+            values.push(Number(body.usefulnessScore));
+        }
+        if (body.metadata !== undefined) {
+            fields.push("metadata = ?");
+            values.push(JSON.stringify(body.metadata));
+        }
+        if (embeddingBuffer) {
+            fields.push("embedding_blob = ?");
+            values.push(embeddingBuffer);
+        }
+        fields.push("updated_at = ?");
+        values.push(Date.now());
+        values.push(nodeId);
+        const sql = `UPDATE memory_nodes SET ${fields.join(", ")} WHERE id = ?`;
+        db.run(sql, ...values);
+        memLog("info", "management", `[api] Updated node ${nodeId}`);
+        return jsonResponse({ success: true });
+    });
+}
+async function handleNodeDelete(ctx) {
+    const nodeId = ctx.params.id;
+    return withDb(ctx.scope, async (db) => {
+        const existing = db.query("SELECT id FROM memory_nodes WHERE id = ?").get(nodeId);
+        if (!existing)
+            return jsonResponse({ success: false, error: "Node not found" }, 404);
+        db.run("DELETE FROM memory_nodes WHERE id = ?", [nodeId]);
+        memLog("info", "management", `[api] Deleted node ${nodeId}`);
+        return jsonResponse({ success: true });
+    });
+}
+export function registerRoutes(router) {
+    router.get(/^\/api\/scopes$/, () => handleScopes());
+    router.get(/^\/api\/nodes$/, (_, ctx) => handleNodes(ctx));
+    router.get(/^\/api\/links$/, (_, ctx) => handleLinks(ctx));
+    router.get(/^\/api\/stats$/, (_, ctx) => handleStats(ctx));
+    router.get(/^\/api\/config$/, () => handleConfigGet());
+    router.put(/^\/api\/config$/, (req) => handleConfigSave(req));
+    router.post(/^\/api\/config$/, (req) => handleConfigSave(req));
+    router.post(/^\/api\/inject$/, (req) => handleInject(req));
+    router.get(/^\/api\/search$/, (req, ctx) => handleSearch(ctx));
+    router.put(/^\/api\/nodes\/(?<id>[^/]+)$/, (req, ctx) => handleNodeUpdate(req, ctx));
+    router.patch(/^\/api\/nodes\/(?<id>[^/]+)$/, (req, ctx) => handleNodeUpdate(req, ctx));
+    router.delete(/^\/api\/nodes\/(?<id>[^/]+)$/, (_, ctx) => handleNodeDelete(ctx));
+}

package/dist/management-server.js

@@ -0,0 +1,4 @@
+export function startManagementServer(_store, _directory, _config) {
+    // No-op: management server is now a standalone CLI
+    // Run: bun run ~/.config/opencode/node_modules/opencode-fractal-memory/dist/management-standalone.js
+}

package/dist/management-standalone.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env bun
+import * as path from "node:path";
+import { memLog } from "./logging";
+import { Router } from "./management/router";
+import { registerRoutes } from "./management/routes";
+import { initDbPaths, serveFile } from "./management/helpers";
+const port = parseInt(process.env.MGMT_PORT || "8787");
+const projectDir = process.env.MGMT_PROJECT_DIR || process.cwd();
+const publicDir = path.join(__dirname, "..", "management", "public");
+initDbPaths(projectDir);
+const router = new Router();
+registerRoutes(router);
+Bun.serve({
+    port,
+    async fetch(req) {
+        const result = await router.handle(req);
+        if (result)
+            return result;
+        const url = new URL(req.url);
+        const pathname = url.pathname;
+        if (pathname === "/") {
+            return serveFile(path.join(publicDir, "index.html"));
+        }
+        const filePath = path.join(publicDir, pathname);
+        if (filePath.startsWith(publicDir)) {
+            return serveFile(filePath);
+        }
+        return new Response("Not found", { status: 404 });
+    },
+});
+memLog("info", "management", `Memory viewer running at http://localhost:${port}`);

package/dist/mcp/logging.js

@@ -0,0 +1,57 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const MCP_LOG_FILE = path.join(os.homedir(), ".config", "opencode", "fractal-memory-server.log");
+const MAX_LOG_SIZE = 1024 * 1024;
+export function mcpLog(level, msg, data) {
+    try {
+        const ts = new Date().toISOString().slice(0, 19).replace("T", " ");
+        const line = `[${ts}] [${level.padEnd(5)}] [mcp] ${msg}` +
+            (data && Object.keys(data).length > 0 ? ` ${JSON.stringify(data)}` : "");
+        try {
+            const stat = fs.statSync(MCP_LOG_FILE);
+            if (stat.size > MAX_LOG_SIZE) {
+                fs.renameSync(MCP_LOG_FILE, MCP_LOG_FILE + ".old");
+            }
+        }
+        catch { }
+        fs.appendFileSync(MCP_LOG_FILE, line + "\n");
+    }
+    catch { }
+}
+export function sanitizeArgs(args) {
+    const sanitized = {};
+    for (const [k, v] of Object.entries(args)) {
+        if (k === "content" && typeof v === "string" && v.length > 100) {
+            sanitized[k] = v.slice(0, 100) + `... [${v.length} chars]`;
+        }
+        else if (k === "query" && typeof v === "string" && v.length > 50) {
+            sanitized[k] = v.slice(0, 50) + `... [${v.length} chars]`;
+        }
+        else {
+            sanitized[k] = v;
+        }
+    }
+    return sanitized;
+}
+export function withMcpLogging(toolName, handler) {
+    return async (args) => {
+        const start = Date.now();
+        mcpLog("info", `call`, { tool: toolName, args: sanitizeArgs(args) });
+        try {
+            const result = await handler(args);
+            const duration = Date.now() - start;
+            const resultSize = JSON.stringify(result).length;
+            mcpLog("info", `ok`, { tool: toolName, durationMs: duration, resultChars: resultSize });
+            return result;
+        }
+        catch (e) {
+            const duration = Date.now() - start;
+            mcpLog("error", `fail`, { tool: toolName, durationMs: duration, error: e instanceof Error ? e.message : String(e) });
+            return {
+                content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true,
+            };
+        }
+    };
+}