@ephemushroom/opencode-claude-mem 0.4.0 → 0.4.2

package/README.md

@@ -118,6 +118,7 @@ The worker endpoint is resolved in this order: `CLAUDE_MEM_WORKER_HOST` /
 | `GET` | `/api/timeline?project={name}&anchor={id}` | Chronological context around an observation |
 | `POST` | `/api/observations/batch` | Fetch full observation details by ID |
 | `GET` | `/api/stats` + `/api/processing-status` | Sidebar status panel |
+| `GET` | `/api/summaries` + `/api/observations` | Sidebar recent items (expanded only) |
 
 Session and observation writes include `platformSource: "opencode"` so
 Claude-Mem can attribute new OpenCode memories separately from Claude Code,
@@ -215,13 +216,28 @@ plugin, so a separately configured MCP server is not required.
 
 ## Sidebar Status
 
-When running in the OpenCode TUI, the plugin registers a sidebar panel titled
-**Memory** via its `./tui` export. It polls `/api/stats` and
-`/api/processing-status` every few seconds and shows worker health, the current
-project, observation/summary/session counts, and the processing queue depth. The
-panel fails open — if the worker is offline it simply shows `worker offline` and
-never blocks the TUI. Requires OpenCode's `@opentui/solid` runtime; if that is
-unavailable the panel is skipped silently.
+When running in the OpenCode TUI, the plugin registers a sidebar section titled
+**Memory** via its `./tui` export, styled after OpenCode's native MCP/Context
+sections: a borderless, click-to-toggle collapsible block.
+
+- **Collapsed (default)** — a single line: `▶ Memory (online, 11.7k obs)`.
+  The summary turns yellow when the worker is processing (`(queue N)`) and red
+  when it is offline (`(offline)`).
+- **Expanded** — click the header to expand: database counts, processing
+  status, the last 3 session summaries (`Recent sessions`), and the last 3
+  observations (`Latest`, with the same type icons used in the injected
+  context: ◆ feature, ● bugfix, ⚖ decision, ○ discovery, …).
+
+Recent items are only fetched while expanded, so the collapsed poll loop stays
+cheap. The panel fails open — if the worker is offline it simply shows the
+offline state and never blocks the TUI. Requires OpenCode's `@opentui/solid`
+runtime; if that is unavailable the panel is skipped silently.
+
+The plugin also self-heals `~/.config/opencode/tui.json` on load (like
+oh-my-openagent does): if the plugin is registered as a server plugin in
+`opencode.json` but missing from the TUI plugin list, it appends itself so the
+sidebar loads without manual configuration. Symlinked `tui.json` files are
+written through, preserving dotfiles setups.
 
 ## Key Implementation Details
 

package/dist/index.js

@@ -12647,6 +12647,51 @@ class WorkerClient {
       return null;
     }
   }
+  static async getRecentSummaries(project, limit) {
+    try {
+      const params = new URLSearchParams({ project, limit: String(limit) });
+      const response = await fetch(`${this.BASE_URL}/api/summaries?${params.toString()}`);
+      if (!response.ok) {
+        return [];
+      }
+      const payload = await response.json();
+      if (!Array.isArray(payload.items)) {
+        return [];
+      }
+      return payload.items.flatMap((item) => {
+        if (!isRecord(item) || typeof item["id"] !== "number") {
+          return [];
+        }
+        const request = typeof item["request"] === "string" ? item["request"].trim() : "";
+        return request ? [{ id: item["id"], request }] : [];
+      });
+    } catch {
+      return [];
+    }
+  }
+  static async getRecentObservations(project, limit) {
+    try {
+      const params = new URLSearchParams({ project, limit: String(limit) });
+      const response = await fetch(`${this.BASE_URL}/api/observations?${params.toString()}`);
+      if (!response.ok) {
+        return [];
+      }
+      const payload = await response.json();
+      if (!Array.isArray(payload.items)) {
+        return [];
+      }
+      return payload.items.flatMap((item) => {
+        if (!isRecord(item) || typeof item["id"] !== "number") {
+          return [];
+        }
+        const title = typeof item["title"] === "string" ? item["title"].trim() : "";
+        const type = typeof item["type"] === "string" ? item["type"] : "";
+        return title ? [{ id: item["id"], type, title }] : [];
+      });
+    } catch {
+      return [];
+    }
+  }
   static async search(query, project, limit) {
     try {
       const params = new URLSearchParams({ query, project });
@@ -12669,6 +12714,74 @@ class WorkerClient {
   }
 }
 
+// src/tui-registration.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var PACKAGE_NAME = "@ephemushroom/opencode-claude-mem";
+function getConfigDir() {
+  const custom2 = process.env["OPENCODE_CONFIG_DIR"]?.trim();
+  return custom2 || join2(homedir2(), ".config", "opencode");
+}
+function readJson(filePath) {
+  try {
+    const parsed = JSON.parse(readFileSync2(filePath, "utf8"));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function pluginEntries(config2) {
+  const { plugin } = config2;
+  if (!Array.isArray(plugin)) {
+    return [];
+  }
+  return plugin.filter((entry) => typeof entry === "string");
+}
+function isOwnEntry(entry) {
+  return entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`);
+}
+function findServerEntry(configDir) {
+  for (const name of ["opencode.json", "opencode.jsonc"]) {
+    const filePath = join2(configDir, name);
+    const config2 = existsSync2(filePath) ? readJson(filePath) : null;
+    const entry = config2 ? pluginEntries(config2).find(isOwnEntry) : undefined;
+    if (entry) {
+      return entry;
+    }
+  }
+  return null;
+}
+function ensureTuiPluginEntry() {
+  try {
+    const configDir = getConfigDir();
+    const serverEntry = findServerEntry(configDir);
+    if (!serverEntry) {
+      return "no-server-entry";
+    }
+    const tuiJsonPath = join2(configDir, "tui.json");
+    let config2 = {};
+    if (existsSync2(tuiJsonPath)) {
+      const parsed = readJson(tuiJsonPath);
+      if (!parsed) {
+        return "malformed";
+      }
+      config2 = parsed;
+    }
+    const plugins = pluginEntries(config2);
+    if (plugins.some(isOwnEntry)) {
+      return "already-present";
+    }
+    mkdirSync(configDir, { recursive: true });
+    const next = { ...config2, plugin: [...plugins, serverEntry] };
+    writeFileSync(tuiJsonPath, `${JSON.stringify(next, null, 2)}
+`);
+    return "added";
+  } catch {
+    return "failed";
+  }
+}
+
 // src/index.ts
 var MAX_OBSERVATION_BYTES = 24 * 1024;
 var MAX_TAG_REPLACEMENTS = 100;
@@ -12773,6 +12886,7 @@ function extractTextFromParts(parts) {
 }
 var ClaudeMemPlugin = async (ctx) => {
   const { project, directory, client } = ctx;
+  ensureTuiPluginEntry();
   const projectRoot = directory || process.cwd();
   const projectName = project?.worktree ? project.worktree.split(/[\\/]/).findLast(Boolean) || "unknown-project" : "unknown-project";
   async function toast(message, variant = "info", duration3 = 3000) {

package/dist/tui-registration.d.ts

@@ -0,0 +1,9 @@
+export type TuiRegistrationResult = 'added' | 'already-present' | 'no-server-entry' | 'malformed' | 'failed';
+/**
+ * Self-heal ~/.config/opencode/tui.json: if this plugin is registered as an
+ * OpenCode server plugin but missing from the TUI plugin list, append it so
+ * the Memory sidebar loads without manual config. Uses writeFileSync (not
+ * atomic rename) so a symlinked tui.json keeps pointing at its dotfiles
+ * target instead of being replaced by a regular file.
+ */
+export declare function ensureTuiPluginEntry(): TuiRegistrationResult;

package/dist/tui.d.ts

@@ -6,6 +6,15 @@ export interface MemSidebarView {
     readonly summaries: number | null;
     readonly queueDepth: number | null;
     readonly isProcessing: boolean;
+    readonly recentSummaries: readonly {
+        id: number;
+        request: string;
+    }[];
+    readonly recentObservations: readonly {
+        id: number;
+        type: string;
+        title: string;
+    }[];
 }
 interface ViewNode {
     readonly kind: 'box' | 'text';
@@ -22,9 +31,9 @@ interface Theme {
     readonly error: string;
     readonly borderSubtle: string;
 }
-export declare function buildMemNodes(view: MemSidebarView, theme: Theme): ViewNode[];
+export declare function buildMemNodes(view: MemSidebarView, theme: Theme, collapsed: boolean, onToggle: () => void): ViewNode[];
 export declare function viewKey(view: MemSidebarView): string;
-export declare function readMemView(project: string): Promise<MemSidebarView>;
+export declare function readMemView(project: string, collapsed: boolean): Promise<MemSidebarView>;
 declare const tuiModule: {
     id: string;
     tui: (api: any) => Promise<void>;

package/dist/tui.js

@@ -314,6 +314,51 @@ class WorkerClient {
       return null;
     }
   }
+  static async getRecentSummaries(project, limit) {
+    try {
+      const params = new URLSearchParams({ project, limit: String(limit) });
+      const response = await fetch(`${this.BASE_URL}/api/summaries?${params.toString()}`);
+      if (!response.ok) {
+        return [];
+      }
+      const payload = await response.json();
+      if (!Array.isArray(payload.items)) {
+        return [];
+      }
+      return payload.items.flatMap((item) => {
+        if (!isRecord(item) || typeof item["id"] !== "number") {
+          return [];
+        }
+        const request = typeof item["request"] === "string" ? item["request"].trim() : "";
+        return request ? [{ id: item["id"], request }] : [];
+      });
+    } catch {
+      return [];
+    }
+  }
+  static async getRecentObservations(project, limit) {
+    try {
+      const params = new URLSearchParams({ project, limit: String(limit) });
+      const response = await fetch(`${this.BASE_URL}/api/observations?${params.toString()}`);
+      if (!response.ok) {
+        return [];
+      }
+      const payload = await response.json();
+      if (!Array.isArray(payload.items)) {
+        return [];
+      }
+      return payload.items.flatMap((item) => {
+        if (!isRecord(item) || typeof item["id"] !== "number") {
+          return [];
+        }
+        const title = typeof item["title"] === "string" ? item["title"].trim() : "";
+        const type = typeof item["type"] === "string" ? item["type"] : "";
+        return title ? [{ id: item["id"], type, title }] : [];
+      });
+    } catch {
+      return [];
+    }
+  }
   static async search(query, project, limit) {
     try {
       const params = new URLSearchParams({ query, project });
@@ -338,15 +383,38 @@ class WorkerClient {
 
 // src/tui.ts
 var POLL_INTERVAL_MS = 5000;
-var LABEL_MAX = 28;
+var LABEL_MAX = 40;
+var RECENT_SUMMARIES = 3;
+var RECENT_OBSERVATIONS = 3;
+var OBSERVATION_TYPE_ICONS = {
+  bugfix: "\u25CF",
+  feature: "\u25C6",
+  refactor: "\u21BB",
+  change: "\u2713",
+  discovery: "\u25CB",
+  decision: "\u2696",
+  security_alert: "\u26A0",
+  security_note: "\u26B7"
+};
 function box(props, children) {
   return { kind: "box", props, children };
 }
 function text(props, value) {
   return { kind: "text", props, text: value };
 }
+var HTML_ENTITIES = {
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&amp;": "&"
+};
+function decodeEntities(value) {
+  return value.replace(/&(?:lt|gt|quot|#39|amp);/g, (entity) => HTML_ENTITIES[entity] ?? entity);
+}
 function truncate(value) {
-  return value.length <= LABEL_MAX ? value : `${value.slice(0, LABEL_MAX - 3)}...`;
+  const decoded = decodeEntities(value);
+  return decoded.length <= LABEL_MAX ? decoded : `${decoded.slice(0, LABEL_MAX - 1)}\u2026`;
 }
 function formatCount(value) {
   if (value === null) {
@@ -354,21 +422,64 @@ function formatCount(value) {
   }
   return value >= 1e4 ? `${(value / 1000).toFixed(1)}k` : String(value);
 }
-function buildMemNodes(view, theme) {
-  const rows = view.healthy ? [
-    text({ fg: theme.success }, "worker online"),
-    text({ fg: theme.text }, `project ${truncate(view.project)}`),
-    text({ fg: theme.text }, `obs ${formatCount(view.observations)} \xB7 sum ${formatCount(view.summaries)}`),
-    text({ fg: theme.textMuted }, `sessions ${formatCount(view.sessions)}`),
-    ...view.isProcessing || (view.queueDepth ?? 0) > 0 ? [text({ fg: theme.warning }, `processing \xB7 queue ${view.queueDepth ?? 0}`)] : []
-  ] : [text({ fg: theme.error }, "worker offline")];
+function summaryLine(view) {
+  if (!view.healthy) {
+    return { label: "(offline)", tone: "err" };
+  }
+  if (view.isProcessing || (view.queueDepth ?? 0) > 0) {
+    return { label: `(queue ${view.queueDepth ?? 0})`, tone: "warn" };
+  }
+  return { label: `(online, ${formatCount(view.observations)} obs)`, tone: "ok" };
+}
+function toneColor(tone, theme) {
+  if (tone === "err") {
+    return theme.error;
+  }
+  return tone === "warn" ? theme.warning : theme.textMuted;
+}
+function bulletRow(icon, iconColor, label, theme) {
+  return box({ flexDirection: "row", gap: 1 }, [
+    text({ fg: iconColor, flexShrink: 0 }, icon),
+    text({ fg: theme.text, wrapMode: "none" }, truncate(label))
+  ]);
+}
+function expandedRows(view, theme) {
+  if (!view.healthy) {
+    return [bulletRow("\u2022", theme.error, "worker offline", theme)];
+  }
+  const rows = [
+    bulletRow("\u2022", theme.success, `obs ${formatCount(view.observations)} \xB7 sum ${formatCount(view.summaries)} \xB7 ses ${formatCount(view.sessions)}`, theme)
+  ];
+  if (view.isProcessing || (view.queueDepth ?? 0) > 0) {
+    rows.push(bulletRow("\u2022", theme.warning, `processing \xB7 queue ${view.queueDepth ?? 0}`, theme));
+  }
+  if (view.recentSummaries.length > 0) {
+    rows.push(text({ fg: theme.textMuted }, "Recent sessions"));
+    for (const summary of view.recentSummaries) {
+      rows.push(bulletRow("\u2022", theme.textMuted, summary.request, theme));
+    }
+  }
+  if (view.recentObservations.length > 0) {
+    rows.push(text({ fg: theme.textMuted }, "Latest"));
+    for (const observation of view.recentObservations) {
+      const icon = OBSERVATION_TYPE_ICONS[observation.type] ?? "\u25CB";
+      rows.push(bulletRow(icon, theme.info, observation.title, theme));
+    }
+  }
+  return rows;
+}
+function buildMemNodes(view, theme, collapsed, onToggle) {
+  const summary = summaryLine(view);
+  const header = box({ flexDirection: "row", gap: 1, onMouseDown: onToggle }, [
+    text({ fg: theme.text }, collapsed ? "\u25B6" : "\u25BC"),
+    text({ fg: theme.info }, "Memory"),
+    ...collapsed ? [text({ fg: toneColor(summary.tone, theme) }, summary.label)] : []
+  ]);
   return [
-    box({
-      borderStyle: "single",
-      borderColor: theme.borderSubtle,
-      flexDirection: "column",
-      padding: 1
-    }, [text({ fg: theme.info }, "Memory"), ...rows])
+    box({ flexDirection: "column", paddingTop: 1 }, [
+      header,
+      ...collapsed ? [] : [box({ flexDirection: "column", paddingLeft: 2 }, expandedRows(view, theme))]
+    ])
   ];
 }
 function viewKey(view) {
@@ -377,7 +488,7 @@ function viewKey(view) {
 function readCount(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-async function readMemView(project) {
+async function readMemView(project, collapsed) {
   const stats = await WorkerClient.getStats();
   if (!stats) {
     return {
@@ -387,9 +498,15 @@ async function readMemView(project) {
       sessions: null,
       summaries: null,
       queueDepth: null,
-      isProcessing: false
+      isProcessing: false,
+      recentSummaries: [],
+      recentObservations: []
     };
   }
+  const [recentSummaries, recentObservations] = collapsed ? [[], []] : await Promise.all([
+    WorkerClient.getRecentSummaries(project, RECENT_SUMMARIES),
+    WorkerClient.getRecentObservations(project, RECENT_OBSERVATIONS)
+  ]);
   return {
     healthy: true,
     project,
@@ -397,9 +514,22 @@ async function readMemView(project) {
     sessions: readCount(stats.database?.sessions),
     summaries: readCount(stats.database?.summaries),
     queueDepth: readCount(stats.processing?.queueDepth),
-    isProcessing: stats.processing?.isProcessing === true
+    isProcessing: stats.processing?.isProcessing === true,
+    recentSummaries,
+    recentObservations
   };
 }
+async function loadSolidCore() {
+  try {
+    const mod = await import("solid-js");
+    if (typeof mod === "object" && mod !== null && typeof mod.createSignal === "function") {
+      return mod;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 function materializeNode(node, solid) {
   const element = solid.createElement(node.kind);
   for (const [name, value] of Object.entries(node.props)) {
@@ -431,16 +561,45 @@ var tuiModule = {
     if (!solid) {
       return;
     }
+    const solidCore = await loadSolidCore();
+    const signal = (value) => {
+      if (solidCore) {
+        return solidCore.createSignal(value);
+      }
+      let current = value;
+      return [
+        () => current,
+        (next) => {
+          current = next;
+        }
+      ];
+    };
     const project = projectNameFromDirectory(String(api.state?.path?.directory ?? ""));
-    let currentView = await readMemView(project);
-    let currentKey = viewKey(currentView);
+    const initialView = await readMemView(project, true);
+    const [collapsed, setCollapsed] = signal(true);
+    const [view, setView] = signal(initialView);
+    let currentKey = viewKey(initialView);
     let disposed = false;
     let inFlight = false;
     let timer = null;
+    const refresh = async () => {
+      const nextView = await readMemView(project, collapsed());
+      const nextKey = viewKey(nextView);
+      if (nextKey !== currentKey) {
+        currentKey = nextKey;
+        setView(nextView);
+        api.renderer.requestRender();
+      }
+    };
+    const onToggle = () => {
+      setCollapsed(!collapsed());
+      api.renderer.requestRender();
+      refresh().catch(() => {});
+    };
     api.slots.register({
       order: 910,
       slots: {
-        sidebar_content: () => materialize(buildMemNodes(currentView, api.theme.current), solid)
+        sidebar_content: () => materialize(buildMemNodes(view(), api.theme.current, collapsed(), onToggle), solid)
       }
     });
     api.renderer.requestRender();
@@ -456,13 +615,7 @@ var tuiModule = {
       }
       inFlight = true;
       try {
-        const nextView = await readMemView(project);
-        const nextKey = viewKey(nextView);
-        if (nextKey !== currentKey) {
-          currentView = nextView;
-          currentKey = nextKey;
-          api.renderer.requestRender();
-        }
+        await refresh();
       } catch {} finally {
         inFlight = false;
         if (!disposed) {

package/dist/worker-client.d.ts

@@ -95,5 +95,20 @@ export declare class WorkerClient {
             queueDepth?: number;
         };
     } | null>;
+    /**
+     * Recent session summaries for the sidebar (GET /api/summaries).
+     */
+    static getRecentSummaries(project: string, limit: number): Promise<{
+        id: number;
+        request: string;
+    }[]>;
+    /**
+     * Recent observations for the sidebar (GET /api/observations).
+     */
+    static getRecentObservations(project: string, limit: number): Promise<{
+        id: number;
+        type: string;
+        title: string;
+    }[]>;
     static search(query: string, project: string, limit?: number): Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ephemushroom/opencode-claude-mem",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "OpenCode plugin for Claude-Mem persistent memory system",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
     }
   },
   "scripts": {
-    "build": "bun build src/index.ts --outfile dist/index.js --target bun --format esm && bun build src/tui.ts --outfile dist/tui.js --target bun --format esm --external @opentui/solid && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "build": "bun build src/index.ts --outfile dist/index.js --target bun --format esm && bun build src/tui.ts --outfile dist/tui.js --target bun --format esm --external @opentui/solid --external solid-js && tsc -p tsconfig.build.json --emitDeclarationOnly",
     "dev": "tsc --watch",
     "clean": "rm -rf dist",
     "lint": "oxlint",