opencode-mem-agents 0.3.1

package/dist/worker.js

@@ -0,0 +1,647 @@
+/**
+ * opencode-mem worker — Standalone HTTP server with SQLite + FTS5
+ *
+ * Runs as a daemon on port 37778 (configurable via OPENCODE_MEM_PORT).
+ * Stores observations in ~/.opencode-mem/opencode-mem.db.
+ *
+ * Endpoints:
+ *   GET  /api/health              — Health check
+ *   GET  /api/search              — FTS5 + metadata search
+ *   GET  /api/timeline            — Chronological window around anchor
+ *   POST /api/observations/batch  — Get observations by IDs
+ *   POST /api/memory/save         — Save an observation
+ *   POST /api/session/tool-result — Capture tool result as observation
+ *   GET  /api/context/session     — Formatted context for system prompt
+ *   GET  /api/activity            — Team activity grouped by agent
+ */
+import http from "http";
+import Database from "better-sqlite3";
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { DASHBOARD_HTML } from "./dashboard-html.js";
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const VERSION = "0.3.1";
+const PORT = parseInt(process.env.OPENCODE_MEM_PORT ?? "37778", 10);
+const HOST = process.env.OPENCODE_MEM_HOST ?? "127.0.0.1";
+const DATA_DIR = process.env.OPENCODE_MEM_DATA_DIR ?? join(homedir(), ".opencode-mem");
+const DB_PATH = join(DATA_DIR, "opencode-mem.db");
+const startedAt = Date.now();
+if (!existsSync(DATA_DIR))
+    mkdirSync(DATA_DIR, { recursive: true });
+// ---------------------------------------------------------------------------
+// Singleton: PID file lock
+// ---------------------------------------------------------------------------
+const PID_FILE = join(DATA_DIR, "worker.pid");
+if (existsSync(PID_FILE)) {
+    const existingPid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+    try {
+        process.kill(existingPid, 0); // check if alive
+        console.log(`[opencode-mem] Worker already running (pid ${existingPid}), exiting`);
+        process.exit(0);
+    }
+    catch {
+        // Process dead, stale PID file — continue startup
+    }
+}
+writeFileSync(PID_FILE, String(process.pid));
+// ---------------------------------------------------------------------------
+// Database
+// ---------------------------------------------------------------------------
+const db = new Database(DB_PATH);
+db.pragma("journal_mode = WAL");
+db.pragma("foreign_keys = ON");
+db.exec(`
+  CREATE TABLE IF NOT EXISTS observations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT DEFAULT '',
+    project TEXT NOT NULL DEFAULT '',
+    type TEXT NOT NULL DEFAULT 'discovery',
+    title TEXT DEFAULT '',
+    text TEXT DEFAULT '',
+    facts TEXT DEFAULT '[]',
+    narrative TEXT DEFAULT '',
+    concepts TEXT DEFAULT '[]',
+    files_read TEXT DEFAULT '[]',
+    files_modified TEXT DEFAULT '[]',
+    agent TEXT DEFAULT '',
+    workflow_id TEXT DEFAULT '',
+    task_id TEXT DEFAULT '',
+    phase TEXT DEFAULT '',
+    signal TEXT DEFAULT 'medium',
+    created_at TEXT NOT NULL,
+    created_at_epoch INTEGER NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_obs_project ON observations(project);
+  CREATE INDEX IF NOT EXISTS idx_obs_type ON observations(type);
+  CREATE INDEX IF NOT EXISTS idx_obs_created ON observations(created_at_epoch DESC);
+  CREATE INDEX IF NOT EXISTS idx_obs_session ON observations(session_id);
+  CREATE INDEX IF NOT EXISTS idx_obs_workflow ON observations(workflow_id);
+  CREATE INDEX IF NOT EXISTS idx_obs_agent ON observations(agent);
+  CREATE INDEX IF NOT EXISTS idx_obs_signal ON observations(signal);
+`);
+// FTS5 — created separately so "IF NOT EXISTS" works for virtual tables
+try {
+    db.exec(`
+    CREATE VIRTUAL TABLE observations_fts USING fts5(
+      title, text, narrative, facts, concepts,
+      content='observations',
+      content_rowid='id'
+    );
+  `);
+}
+catch {
+    // Already exists
+}
+// FTS5 sync triggers
+const triggers = [
+    `CREATE TRIGGER IF NOT EXISTS obs_fts_ai AFTER INSERT ON observations BEGIN
+    INSERT INTO observations_fts(rowid, title, text, narrative, facts, concepts)
+    VALUES (new.id, new.title, new.text, new.narrative, new.facts, new.concepts);
+  END`,
+    `CREATE TRIGGER IF NOT EXISTS obs_fts_ad AFTER DELETE ON observations BEGIN
+    INSERT INTO observations_fts(observations_fts, rowid, title, text, narrative, facts, concepts)
+    VALUES('delete', old.id, old.title, old.text, old.narrative, old.facts, old.concepts);
+  END`,
+    `CREATE TRIGGER IF NOT EXISTS obs_fts_au AFTER UPDATE ON observations BEGIN
+    INSERT INTO observations_fts(observations_fts, rowid, title, text, narrative, facts, concepts)
+    VALUES('delete', old.id, old.title, old.text, old.narrative, old.facts, old.concepts);
+    INSERT INTO observations_fts(rowid, title, text, narrative, facts, concepts)
+    VALUES (new.id, new.title, new.text, new.narrative, new.facts, new.concepts);
+  END`,
+];
+for (const t of triggers) {
+    try {
+        db.exec(t);
+    }
+    catch { /* already exists */ }
+}
+// ---------------------------------------------------------------------------
+// Prepared statements
+// ---------------------------------------------------------------------------
+const insertObs = db.prepare(`
+  INSERT INTO observations
+    (session_id, project, type, title, text, facts, narrative, concepts,
+     files_read, files_modified, agent, workflow_id, task_id, phase, signal,
+     created_at, created_at_epoch)
+  VALUES
+    (@session_id, @project, @type, @title, @text, @facts, @narrative, @concepts,
+     @files_read, @files_modified, @agent, @workflow_id, @task_id, @phase, @signal,
+     @created_at, @created_at_epoch)
+`);
+const getObsById = db.prepare(`SELECT * FROM observations WHERE id = ?`);
+const getObsByIds = db.prepare(`
+  SELECT * FROM observations WHERE id IN (SELECT value FROM json_each(?))
+  ORDER BY created_at_epoch DESC
+`);
+const searchFts = db.prepare(`
+  SELECT o.* FROM observations o
+  JOIN observations_fts fts ON o.id = fts.rowid
+  WHERE observations_fts MATCH ?
+  ORDER BY rank
+  LIMIT ?
+`);
+const searchByProject = db.prepare(`
+  SELECT * FROM observations
+  WHERE project = ?
+  ORDER BY created_at_epoch DESC
+  LIMIT ?
+`);
+const searchByType = db.prepare(`
+  SELECT * FROM observations
+  WHERE type = ? AND (project = ? OR ? = '')
+  ORDER BY created_at_epoch DESC
+  LIMIT ?
+`);
+const searchRecent = db.prepare(`
+  SELECT * FROM observations
+  WHERE (project = ? OR ? = '')
+  ORDER BY created_at_epoch DESC
+  LIMIT ?
+`);
+const getTimeline = db.prepare(`
+  SELECT * FROM observations
+  WHERE (project = ? OR ? = '')
+  ORDER BY created_at_epoch ASC
+  LIMIT 1000
+`);
+const getRecentForContext = db.prepare(`
+  SELECT * FROM observations
+  WHERE (project = ? OR ? = '')
+  ORDER BY created_at_epoch DESC
+  LIMIT ?
+`);
+const getActivityByProject = db.prepare(`
+  SELECT * FROM observations
+  WHERE (project = ? OR ? = '')
+  ORDER BY created_at_epoch DESC
+  LIMIT ?
+`);
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function json(res, data, status = 200) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+function text(res, data, status = 200) {
+    res.writeHead(status, { "Content-Type": "text/plain" });
+    res.end(data);
+}
+async function readBody(req, maxBytes = 65536) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        total += chunk.length;
+        if (total > maxBytes)
+            throw new Error("Payload too large");
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+function parseQuery(url) {
+    const q = {};
+    url.searchParams.forEach((v, k) => { q[k] = v; });
+    return q;
+}
+function sanitizeFtsQuery(query) {
+    // Escape special FTS5 characters, wrap terms for prefix matching
+    return query
+        .replace(/[*"():^]/g, " ")
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((term) => `"${term}"`)
+        .join(" ");
+}
+// ---------------------------------------------------------------------------
+// Dashboard
+// ---------------------------------------------------------------------------
+function handleDashboard(res) {
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(DASHBOARD_HTML);
+}
+// ---------------------------------------------------------------------------
+// Route handlers
+// ---------------------------------------------------------------------------
+function handleHealth(res) {
+    json(res, {
+        status: "ok",
+        version: VERSION,
+        port: PORT,
+        dataDir: DATA_DIR,
+        uptime: Date.now() - startedAt,
+        pid: process.pid,
+    });
+}
+function handleSearch(res, params) {
+    const query = params.query ?? "";
+    const project = params.project ?? "";
+    const type = params.type ?? "";
+    const limit = Math.min(parseInt(params.limit ?? "20", 10), 100);
+    const dateStart = params.dateStart ?? "";
+    const dateEnd = params.dateEnd ?? "";
+    const sinceId = parseInt(params.since_id ?? "0", 10) || 0;
+    const agentFilter = params.agent ?? "";
+    let rows;
+    if (query) {
+        const sanitized = sanitizeFtsQuery(query);
+        if (!sanitized) {
+            rows = searchRecent.all(project, project, limit);
+        }
+        else {
+            try {
+                rows = searchFts.all(sanitized, limit);
+                // Post-filter by project if specified
+                if (project) {
+                    rows = rows.filter((r) => r.project === project);
+                }
+            }
+            catch {
+                // FTS query failed — fall back to recent
+                rows = searchRecent.all(project, project, limit);
+            }
+        }
+    }
+    else if (type) {
+        rows = searchByType.all(type, project, project, limit);
+    }
+    else if (project) {
+        rows = searchByProject.all(project, limit);
+    }
+    else {
+        rows = searchRecent.all("", "", limit);
+    }
+    // Post-filters: since_id, agent, date
+    if (sinceId > 0) {
+        rows = rows.filter((r) => r.id > sinceId);
+    }
+    if (agentFilter) {
+        rows = rows.filter((r) => r.agent === agentFilter);
+    }
+    if (dateStart || dateEnd) {
+        const start = dateStart ? new Date(dateStart).getTime() : 0;
+        const end = dateEnd ? new Date(dateEnd).getTime() : Infinity;
+        rows = rows.filter((r) => r.created_at_epoch >= start && r.created_at_epoch <= end);
+    }
+    json(res, {
+        observations: rows.slice(0, limit),
+        totalResults: rows.length,
+        query,
+    });
+}
+function handleTimeline(res, params) {
+    const anchorStr = params.anchor ?? "";
+    const query = params.query ?? "";
+    const depthBefore = Math.min(parseInt(params.depth_before ?? "10", 10), 50);
+    const depthAfter = Math.min(parseInt(params.depth_after ?? "10", 10), 50);
+    const project = params.project ?? "";
+    const allObs = getTimeline.all(project, project);
+    if (allObs.length === 0) {
+        text(res, "No observations found.");
+        return;
+    }
+    // Find anchor position
+    let anchorIdx = -1;
+    if (anchorStr) {
+        const anchorId = parseInt(anchorStr, 10);
+        if (!isNaN(anchorId)) {
+            anchorIdx = allObs.findIndex((o) => o.id === anchorId);
+        }
+    }
+    if (anchorIdx === -1 && query) {
+        // Search for anchor via FTS
+        const sanitized = sanitizeFtsQuery(query);
+        if (sanitized) {
+            try {
+                const match = searchFts.get(sanitized, 1);
+                if (match) {
+                    anchorIdx = allObs.findIndex((o) => o.id === match.id);
+                }
+            }
+            catch { /* ignore */ }
+        }
+    }
+    if (anchorIdx === -1) {
+        anchorIdx = allObs.length - 1; // default to most recent
+    }
+    // Extract window
+    const start = Math.max(0, anchorIdx - depthBefore);
+    const end = Math.min(allObs.length, anchorIdx + depthAfter + 1);
+    const window = allObs.slice(start, end);
+    // Format as text
+    const typeEmoji = {
+        bugfix: "bugfix",
+        feature: "feature",
+        refactor: "refactor",
+        discovery: "discovery",
+        decision: "decision",
+        change: "change",
+        contract: "contract",
+        blocker: "blocker",
+        "test-result": "test-result",
+        "review-finding": "review",
+    };
+    const lines = [
+        `# Timeline`,
+        `Anchor: #${allObs[anchorIdx]?.id ?? "?"} | Window: ${depthBefore} before, ${depthAfter} after | Items: ${window.length}`,
+        "",
+    ];
+    let currentDay = "";
+    for (const obs of window) {
+        const d = new Date(obs.created_at_epoch);
+        const day = d.toISOString().slice(0, 10);
+        if (day !== currentDay) {
+            currentDay = day;
+            lines.push(`## ${day}`, "");
+        }
+        const time = d.toISOString().slice(11, 16);
+        const marker = obs.id === allObs[anchorIdx]?.id ? " <-- anchor" : "";
+        const t = typeEmoji[obs.type] ?? obs.type;
+        lines.push(`- **${time}** [${t}] #${obs.id}: ${obs.title || obs.text?.substring(0, 80) || "(no title)"}${marker}`);
+    }
+    text(res, lines.join("\n"));
+}
+function handleObservationsBatch(res, body) {
+    const ids = (body.ids ?? []).filter((id) => typeof id === 'number' && Number.isInteger(id));
+    if (ids.length === 0) {
+        json(res, { observations: [] });
+        return;
+    }
+    const rows = getObsByIds.all(JSON.stringify(ids));
+    json(res, { observations: rows });
+}
+const VALID_TYPES = new Set([
+    "discovery", "decision", "bugfix", "feature", "refactor", "change",
+    "contract", "blocker", "test-result", "review-finding",
+]);
+const MAX_TEXT_LENGTH = 8192;
+const MAX_NARRATIVE_LENGTH = 4096;
+const MAX_TITLE_LENGTH = 500;
+function sanitizeText(s, max) {
+    return s.substring(0, max).replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+}
+function handleMemorySave(res, body) {
+    const now = Date.now();
+    const type = VALID_TYPES.has(body.type) ? body.type : "discovery";
+    let result;
+    try {
+        result = insertObs.run({
+            session_id: body.sessionId ?? "",
+            project: body.project ?? "",
+            type,
+            title: sanitizeText(String(body.title ?? ""), MAX_TITLE_LENGTH),
+            text: sanitizeText(String(body.text ?? ""), MAX_TEXT_LENGTH),
+            facts: JSON.stringify(body.facts ?? []),
+            narrative: sanitizeText(String(body.narrative ?? ""), MAX_NARRATIVE_LENGTH),
+            concepts: JSON.stringify(body.concepts ?? []),
+            files_read: JSON.stringify(body.files_read ?? []),
+            files_modified: JSON.stringify(body.files_modified ?? []),
+            agent: body.agent ?? body.metadata?.agent?.agentName ?? "",
+            workflow_id: body.workflow_id ?? body.metadata?.agent?.workflowId ?? "",
+            task_id: body.task_id ?? body.metadata?.agent?.taskId ?? "",
+            phase: body.phase ?? body.metadata?.agent?.phase ?? "",
+            signal: body.signal ?? body.metadata?.signal ?? "medium",
+            created_at: new Date(now).toISOString(),
+            created_at_epoch: now,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "DB write failed";
+        json(res, { error: `Failed to save observation: ${msg}` }, 503);
+        return;
+    }
+    json(res, { id: result.lastInsertRowid, status: "saved" });
+}
+function handleToolResult(res, body) {
+    const now = Date.now();
+    const toolName = sanitizeText(String(body.tool ?? "unknown"), 100);
+    const argsStr = typeof body.args === "string"
+        ? body.args.substring(0, 200)
+        : JSON.stringify(body.args ?? {}).substring(0, 200);
+    // Extract files_modified from body if provided (populated by plugin auto-capture)
+    const filesModified = Array.isArray(body.files_modified)
+        ? JSON.stringify(body.files_modified)
+        : "[]";
+    let result;
+    try {
+        result = insertObs.run({
+            session_id: body.sessionId ?? "",
+            project: body.project ?? "",
+            type: "change",
+            title: sanitizeText(`[tool] ${toolName}`, MAX_TITLE_LENGTH),
+            text: sanitizeText(String(body.output ?? ""), MAX_TEXT_LENGTH),
+            facts: "[]",
+            narrative: sanitizeText(`Tool ${toolName} called with: ${argsStr}`, MAX_NARRATIVE_LENGTH),
+            concepts: "[]",
+            files_read: "[]",
+            files_modified: filesModified,
+            agent: body.metadata?.agent?.agentName ?? "",
+            workflow_id: body.metadata?.agent?.workflowId ?? "",
+            task_id: body.metadata?.agent?.taskId ?? "",
+            phase: body.metadata?.agent?.phase ?? "",
+            signal: body.metadata?.signal ?? "medium",
+            created_at: new Date(now).toISOString(),
+            created_at_epoch: now,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "DB write failed";
+        json(res, { error: `Failed to capture tool result: ${msg}` }, 503);
+        return;
+    }
+    json(res, { id: result.lastInsertRowid, status: "captured" });
+}
+function handleContextSession(res, params) {
+    const project = params.project ?? "";
+    const limit = Math.min(parseInt(params.limit ?? "10", 10), 30);
+    const agentFilter = params.agent ?? "";
+    let rows = getRecentForContext.all(project, project, limit);
+    if (agentFilter) {
+        rows = rows.filter((r) => r.agent === agentFilter);
+    }
+    if (rows.length === 0) {
+        text(res, "");
+        return;
+    }
+    const MAX_ITEM_LENGTH = 300;
+    const lines = [
+        `# [opencode-mem] Recent context (${rows.length} observations)`,
+        "",
+    ];
+    // Group by type
+    const byType = {};
+    for (const r of rows) {
+        (byType[r.type] ??= []).push(r);
+    }
+    for (const [type, obs] of Object.entries(byType)) {
+        lines.push(`## ${type} (${obs.length})`);
+        for (const o of obs) {
+            const agentTag = o.agent ? ` [${o.agent}]` : "";
+            const content = o.title || o.text?.substring(0, MAX_ITEM_LENGTH) || "(empty)";
+            lines.push(`- #${o.id}${agentTag}: ${content.substring(0, MAX_ITEM_LENGTH)}`);
+        }
+        lines.push("");
+    }
+    text(res, lines.join("\n"));
+}
+function handleActivity(res, params) {
+    const project = params.project ?? "";
+    const sinceId = parseInt(params.since_id ?? "0", 10) || 0;
+    const limit = Math.min(parseInt(params.limit ?? "100", 10), 500);
+    let rows = getActivityByProject.all(project, project, limit);
+    // Filter by since_id for incremental polling
+    if (sinceId > 0) {
+        rows = rows.filter((r) => r.id > sinceId);
+    }
+    // Group by agent
+    const agentSets = {};
+    for (const r of rows) {
+        const agentName = r.agent || "unknown";
+        if (!agentSets[agentName]) {
+            agentSets[agentName] = { observations: [], files_modified: new Set(), last_active: 0 };
+        }
+        const agent = agentSets[agentName];
+        agent.observations.push({
+            id: r.id,
+            type: r.type,
+            title: r.title,
+            signal: r.signal,
+            phase: r.phase,
+            task_id: r.task_id,
+            created_at_epoch: r.created_at_epoch,
+        });
+        if (r.created_at_epoch > agent.last_active) {
+            agent.last_active = r.created_at_epoch;
+        }
+        // Roll up files_modified from JSON arrays
+        try {
+            const files = JSON.parse(r.files_modified || "[]");
+            if (Array.isArray(files)) {
+                for (const f of files) {
+                    if (f)
+                        agent.files_modified.add(f);
+                }
+            }
+        }
+        catch { /* malformed JSON — skip */ }
+    }
+    // Convert Sets to arrays for JSON serialization
+    const agents = {};
+    for (const [name, data] of Object.entries(agentSets)) {
+        agents[name] = {
+            observations: data.observations,
+            files_modified: Array.from(data.files_modified),
+            last_active: data.last_active,
+        };
+    }
+    json(res, {
+        project,
+        since_id: sinceId,
+        total_observations: rows.length,
+        agents,
+    });
+}
+// ---------------------------------------------------------------------------
+// HTTP Server
+// ---------------------------------------------------------------------------
+const server = http.createServer(async (req, res) => {
+    // CORS for local tools
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    const url = new URL(req.url ?? "/", `http://${HOST}:${PORT}`);
+    const path = url.pathname;
+    const params = parseQuery(url);
+    try {
+        // GET routes
+        if (req.method === "GET") {
+            if (path === "/" || path === "/dashboard") {
+                return handleDashboard(res);
+            }
+            if (path === "/api/health" || path === "/api/readiness") {
+                return handleHealth(res);
+            }
+            if (path === "/api/search") {
+                return handleSearch(res, params);
+            }
+            if (path === "/api/timeline") {
+                return handleTimeline(res, params);
+            }
+            if (path === "/api/context/session") {
+                return handleContextSession(res, params);
+            }
+            if (path === "/api/activity") {
+                return handleActivity(res, params);
+            }
+        }
+        // POST routes
+        if (req.method === "POST") {
+            let rawBody;
+            try {
+                rawBody = await readBody(req);
+            }
+            catch (err) {
+                json(res, { error: "Payload too large" }, 413);
+                return;
+            }
+            let body;
+            try {
+                body = rawBody ? JSON.parse(rawBody) : {};
+            }
+            catch {
+                json(res, { error: "Invalid JSON body" }, 400);
+                return;
+            }
+            if (path === "/api/observations/batch") {
+                return handleObservationsBatch(res, body);
+            }
+            if (path === "/api/memory/save") {
+                return handleMemorySave(res, body);
+            }
+            if (path === "/api/session/tool-result") {
+                return handleToolResult(res, body);
+            }
+        }
+        // 404
+        json(res, { error: "Not found" }, 404);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Internal error";
+        console.error(`[opencode-mem] Error on ${path}:`, msg);
+        json(res, { error: msg }, 500);
+    }
+});
+server.listen(PORT, HOST, () => {
+    console.log(`[opencode-mem] Worker listening on http://${HOST}:${PORT}`);
+    console.log(`[opencode-mem] Database: ${DB_PATH}`);
+});
+// Graceful shutdown
+function cleanup() {
+    try {
+        unlinkSync(PID_FILE);
+    }
+    catch { }
+    db.close();
+}
+process.on("SIGTERM", () => {
+    console.log("[opencode-mem] Shutting down...");
+    server.close(() => {
+        cleanup();
+        process.exit(0);
+    });
+});
+process.on("SIGINT", () => {
+    server.close(() => {
+        cleanup();
+        process.exit(0);
+    });
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "opencode-mem-agents",
+  "version": "0.3.1",
+  "description": "Self-contained memory plugin for OpenCode — cross-session persistence with SQLite + FTS5, signal-based capture, role-scoped context, and agent coordination",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build:dashboard": "cd dashboard && npm run build",
+    "embed": "node scripts/embed-dashboard.js",
+    "build": "npm run build:dashboard && npm run embed && tsc",
+    "dev": "tsc --watch",
+    "test": "node test/smoke.mjs",
+    "postinstall": "sed -i'' -e 's|from \"./tool\"|from \"./tool.js\"|' node_modules/@opencode-ai/plugin/dist/index.js 2>/dev/null || true",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.2.6",
+    "better-sqlite3": "^12.6.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}