@ephemushroom/opencode-claude-mem 0.3.3 → 0.4.1

package/README.md

@@ -39,9 +39,13 @@ into new OpenCode sessions automatically.
   compaction so long conversations keep their historical context.
 - **Observation Capture** — Sends tool observations to Claude-Mem for future
   retrieval and summarization.
-- **Native Memory Search** — Exposes a `mem-search` OpenCode tool backed by the
-  Claude-Mem worker search API, so search remains available without the Claude
-  Code compatibility bridge.
+- **Native Memory Tools** — Exposes `mem-search`, `mem-timeline`, and
+  `mem-get-observations` OpenCode tools backed by the Claude-Mem worker API,
+  covering the full search → timeline → details workflow without the Claude
+  Code compatibility bridge or an MCP server.
+- **Sidebar Status** — Registers a TUI sidebar panel ("Memory") showing worker
+  health, project, observation/summary/session counts, and processing queue
+  depth, refreshed every few seconds.
 - **Observation Hardening** — Skips low-value meta tools, strips
   `<claude-mem-context>` and `<private>` tags before storage, and truncates
   oversized observation payloads by UTF-8 byte size.
@@ -91,7 +95,9 @@ The worker endpoint is resolved in this order: `CLAUDE_MEM_WORKER_HOST` /
 | `SessionStart` | `experimental.session.compacting` | Preserve memory during compaction |
 | `UserPromptSubmit` | `chat.message` | Initialize session with real user prompt |
 | `PostToolUse` | `tool.execute.after` | Capture tool observations |
-| Claude-Mem MCP | `tool` (`mem-search`) | Search memory from OpenCode |
+| Claude-Mem MCP `search` | `tool` (`mem-search`) | Search memory from OpenCode |
+| Claude-Mem MCP `timeline` | `tool` (`mem-timeline`) | Chronological context around an observation |
+| Claude-Mem MCP `get_observations` | `tool` (`mem-get-observations`) | Fetch full observation details by ID |
 | _(streaming)_ | `event` (`message.updated`) | Capture assistant text (debounced) |
 | _(streaming)_ | `event` (`file.edited`) | Record file edit observations |
 | _(compaction)_ | `event` (`session.compacted`) | Summarize after OpenCode compacts |
@@ -109,6 +115,10 @@ The worker endpoint is resolved in this order: `CLAUDE_MEM_WORKER_HOST` /
 | `POST` | `/api/sessions/summarize` | Trigger summarization |
 | `POST` | `/api/sessions/complete` | Complete session |
 | `GET` | `/api/search?query={query}&project={name}` | Search memory |
+| `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,
@@ -181,23 +191,53 @@ Once installed, the plugin works automatically:
   accumulating stale `pending_messages` (the "queueDepth never decreases"
   failure mode).
 
-## Memory Search
+## Memory Tools
 
-This plugin provides a native OpenCode tool named `mem-search`. It calls the
-Claude-Mem worker's `/api/search` endpoint for the current project and returns
-the same formatted result text the worker exposes over HTTP.
+This plugin provides three native OpenCode tools backed by the Claude-Mem
+worker's HTTP API. They cover the same search → timeline → details workflow as
+the upstream Claude-Mem MCP server, without requiring an MCP server or the
+Claude Code compatibility bridge:
+
+- **`mem-search`** — `GET /api/search`. Returns a formatted index of matching
+  observations (with IDs) for the current project.
+- **`mem-timeline`** — `GET /api/timeline`. Given an observation ID as `anchor`
+  (or a `query` to locate one), returns the chronological records around it.
+- **`mem-get-observations`** — `POST /api/observations/batch`. Fetches full
+  observation details for a list of IDs (e.g. IDs surfaced in the injected
+  memory context or by `mem-search`).
 
 Claude Code's claude-mem plugin also registers an MCP server through its own
 `.mcp.json`. OpenCode does not automatically load Claude Code plugin MCP
 servers. If you previously saw Claude-Mem MCP tools in OpenCode, they were most
 likely supplied by a Claude Code compatibility bridge such as oh-my-openagent.
 Disabling that bridge for `claude-mem@thedotmack` removes those bridged MCP
-tools; `mem-search` is the native replacement inside this plugin.
-
-The richer Claude-Mem MCP workflow (`search`, `timeline`, `get_observations`) can
-still be configured separately in OpenCode if you want it. It is not required for
-automatic context injection, observation capture, summarization, or the built-in
-`mem-search` tool.
+tools; the three `mem-*` tools above are the native replacements inside this
+plugin, so a separately configured MCP server is not required.
+
+## Sidebar Status
+
+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
 
@@ -281,12 +321,13 @@ plugin load. If that toast still appears:
   design.
 - Very large tool outputs are truncated before storage.
 
-### Memory search is unavailable
+### Memory tools are unavailable
 
-- Use the built-in `mem-search` tool exposed by this plugin.
-- If you specifically need Claude-Mem's MCP `timeline` or `get_observations`
-  tools, configure the Claude-Mem MCP server separately in OpenCode or enable a
-  compatible bridge for MCP only.
+- Use the built-in `mem-search`, `mem-timeline`, and `mem-get-observations`
+  tools exposed by this plugin — they cover the full Claude-Mem search workflow
+  natively, so a separate MCP server is not required.
+- If the tools return `worker is offline`, confirm the worker health endpoint
+  responds (see above).
 
 ## Development
 

package/dist/index.js

@@ -12574,6 +12574,124 @@ class WorkerClient {
       return null;
     }
   }
+  static async timeline(options) {
+    try {
+      const params = new URLSearchParams({ project: options.project });
+      if (options.anchor !== undefined) {
+        params.set("anchor", String(options.anchor));
+      }
+      if (options.query) {
+        params.set("query", options.query);
+      }
+      if (options.depthBefore !== undefined) {
+        params.set("depth_before", String(options.depthBefore));
+      }
+      if (options.depthAfter !== undefined) {
+        params.set("depth_after", String(options.depthAfter));
+      }
+      const response = await fetch(`${this.BASE_URL}/api/timeline?${params.toString()}`);
+      if (!response.ok) {
+        return "";
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        return extractTextContent(await response.json()) || "";
+      }
+      const text = await response.text();
+      return text.trim();
+    } catch {
+      return "";
+    }
+  }
+  static async getObservations(ids, project) {
+    try {
+      const body = { ids };
+      if (project) {
+        body["project"] = project;
+      }
+      const response = await fetch(`${this.BASE_URL}/api/observations/batch`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        return "";
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        const payload = await response.json();
+        if (Array.isArray(payload)) {
+          return payload.length ? JSON.stringify(payload, null, 2) : "";
+        }
+        return extractTextContent(payload) || "";
+      }
+      const text = await response.text();
+      return text.trim();
+    } catch {
+      return "";
+    }
+  }
+  static async getStats() {
+    try {
+      const [statsRes, processingRes] = await Promise.all([
+        fetch(`${this.BASE_URL}/api/stats`),
+        fetch(`${this.BASE_URL}/api/processing-status`)
+      ]);
+      if (!statsRes.ok) {
+        return null;
+      }
+      const stats = await statsRes.json();
+      const processing = processingRes.ok ? await processingRes.json() : undefined;
+      return { database: stats.database, processing };
+    } catch {
+      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 });
@@ -12596,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;
@@ -12605,7 +12791,9 @@ var META_TOOLS = new Set([
   "getmcpresource",
   "listmcpresourcestool",
   "listmcptools",
+  "mem-get-observations",
   "mem-search",
+  "mem-timeline",
   "skill",
   "slashcommand",
   "todowrite"
@@ -12698,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) {
@@ -12842,6 +13031,46 @@ var ClaudeMemPlugin = async (ctx) => {
           const result = await WorkerClient.search(query, projectName, limit);
           return result || `No Claude-Mem results found for "${query}".`;
         }
+      }),
+      "mem-timeline": tool({
+        description: "Get chronological Claude-Mem context around an observation. Use after mem-search: pass an observation ID as anchor (or a query to find the anchor automatically) to see what happened before/after.",
+        args: {
+          anchor: tool.schema.number().int().positive().optional().describe("Observation ID to center the timeline around"),
+          query: tool.schema.string().min(1).optional().describe("Query to locate the anchor automatically (used when anchor is omitted)"),
+          depth_before: tool.schema.number().int().min(0).max(20).optional().describe("Items before the anchor (default 3)"),
+          depth_after: tool.schema.number().int().min(0).max(20).optional().describe("Items after the anchor (default 3)")
+        },
+        execute: async ({ anchor, query, depth_before, depth_after }) => {
+          if (anchor === undefined && !query) {
+            return "Provide either an anchor observation ID or a query.";
+          }
+          const isHealthy = await checkWorkerAndToast();
+          if (!isHealthy) {
+            return "Claude-Mem worker is offline. Start Claude-Mem and retry.";
+          }
+          const result = await WorkerClient.timeline({
+            project: projectName,
+            anchor,
+            query,
+            depthBefore: depth_before,
+            depthAfter: depth_after
+          });
+          return result || "No Claude-Mem timeline results found.";
+        }
+      }),
+      "mem-get-observations": tool({
+        description: "Fetch full Claude-Mem observation details by ID. Use for IDs shown in the injected memory context or returned by mem-search/mem-timeline.",
+        args: {
+          ids: tool.schema.array(tool.schema.number().int().positive()).min(1).max(50).describe("Observation IDs to fetch")
+        },
+        execute: async ({ ids }) => {
+          const isHealthy = await checkWorkerAndToast();
+          if (!isHealthy) {
+            return "Claude-Mem worker is offline. Start Claude-Mem and retry.";
+          }
+          const result = await WorkerClient.getObservations(ids, projectName);
+          return result || `No Claude-Mem observations found for IDs [${ids.join(", ")}].`;
+        }
       })
     },
     event: async ({ event }) => {

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

@@ -0,0 +1,41 @@
+export interface MemSidebarView {
+    readonly healthy: boolean;
+    readonly project: string;
+    readonly observations: number | null;
+    readonly sessions: number | null;
+    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';
+    readonly props: Record<string, unknown>;
+    readonly children?: readonly ViewNode[];
+    readonly text?: string;
+}
+interface Theme {
+    readonly text: string;
+    readonly textMuted: string;
+    readonly info: string;
+    readonly success: string;
+    readonly warning: string;
+    readonly error: string;
+    readonly borderSubtle: string;
+}
+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, collapsed: boolean): Promise<MemSidebarView>;
+declare const tuiModule: {
+    id: string;
+    tui: (api: any) => Promise<void>;
+};
+export default tuiModule;

package/dist/tui.js

@@ -0,0 +1,616 @@
+// @bun
+var __require = import.meta.require;
+
+// src/worker-client.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { spawn } from "child_process";
+var HEALTH_TIMEOUT_MS = 1000;
+var AUTOSTART_POLL_INTERVAL_MS = 500;
+var AUTOSTART_POLL_MAX_ATTEMPTS = 16;
+var DEFAULT_WORKER_HOST = "127.0.0.1";
+var DEFAULT_WORKER_PORT = 37777;
+var PLATFORM_SOURCE = "opencode";
+var SETTINGS_FILE = join(homedir(), ".claude-mem", "settings.json");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+function readPort(value) {
+  const text = readString(value);
+  if (!text || !/^\d+$/.test(text)) {
+    return null;
+  }
+  const port = Number(text);
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : null;
+}
+function parseSettings(rawSettings) {
+  if (!rawSettings) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(rawSettings);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function parseWorkerEndpoint(env, rawSettings) {
+  const settings = parseSettings(rawSettings);
+  const host = readString(env["CLAUDE_MEM_WORKER_HOST"]) ?? readString(settings["CLAUDE_MEM_WORKER_HOST"]) ?? DEFAULT_WORKER_HOST;
+  const port = readPort(env["CLAUDE_MEM_WORKER_PORT"]) ?? readPort(settings["CLAUDE_MEM_WORKER_PORT"]) ?? DEFAULT_WORKER_PORT;
+  return { host, port };
+}
+function readSettingsRaw() {
+  try {
+    return readFileSync(SETTINGS_FILE, "utf8");
+  } catch {
+    return null;
+  }
+}
+function getWorkerBaseUrl() {
+  const endpoint = parseWorkerEndpoint(process.env, readSettingsRaw());
+  return `http://${endpoint.host}:${endpoint.port}`;
+}
+function extractTextContent(value) {
+  if (typeof value === "string") {
+    return value.trim() || null;
+  }
+  if (!isRecord(value)) {
+    return null;
+  }
+  const { content } = value;
+  if (typeof content === "string") {
+    return content.trim() || null;
+  }
+  if (Array.isArray(content)) {
+    const text2 = content.map((part) => {
+      if (!isRecord(part) || part["type"] !== "text" || typeof part["text"] !== "string") {
+        return "";
+      }
+      return part["text"];
+    }).filter(Boolean).join(`
+`).trim();
+    return text2 || null;
+  }
+  const text = JSON.stringify(value, null, 2);
+  return text === "{}" || text === "null" ? null : text;
+}
+
+class WorkerClient {
+  static BASE_URL = getWorkerBaseUrl();
+  static autoStartPromise = null;
+  static async isHealthy() {
+    try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+      const response = await fetch(`${this.BASE_URL}/api/health`, {
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  static async ensureRunning() {
+    const result = await this.tryAutoStart();
+    return result === "already-running" || result === "started";
+  }
+  static tryAutoStart() {
+    if (!this.autoStartPromise) {
+      this.autoStartPromise = this.runAutoStart().catch(() => "spawn-failed");
+    }
+    return this.autoStartPromise;
+  }
+  static async runAutoStart() {
+    if (await this.isHealthy()) {
+      return "already-running";
+    }
+    const bunPath = this.findBun();
+    if (!bunPath) {
+      return "no-bun";
+    }
+    try {
+      const child = spawn(bunPath, ["x", "claude-mem", "start"], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: process.env
+      });
+      child.on("error", () => {});
+      child.unref();
+    } catch {
+      return "spawn-failed";
+    }
+    for (let i = 0;i < AUTOSTART_POLL_MAX_ATTEMPTS; i++) {
+      await new Promise((resolve) => setTimeout(resolve, AUTOSTART_POLL_INTERVAL_MS));
+      if (await this.isHealthy()) {
+        return "started";
+      }
+    }
+    return "timeout";
+  }
+  static findBun() {
+    const bunGlobal = globalThis.Bun;
+    if (bunGlobal && typeof bunGlobal.which === "function") {
+      try {
+        const found = bunGlobal.which("bun");
+        if (typeof found === "string" && found) {
+          return found;
+        }
+      } catch {}
+    }
+    const path = process.env.PATH || "";
+    const sep = process.platform === "win32" ? ";" : ":";
+    const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+    const slash = process.platform === "win32" ? "\\" : "/";
+    const dirs = path.split(sep).filter(Boolean);
+    for (const dir of dirs) {
+      const trailing = dir.endsWith("/") || dir.endsWith("\\") ? "" : slash;
+      for (const ext of exts) {
+        const candidate = `${dir}${trailing}bun${ext}`;
+        try {
+          if (existsSync(candidate)) {
+            return candidate;
+          }
+        } catch {}
+      }
+    }
+    return null;
+  }
+  static async sessionInit(contentSessionId, project, prompt) {
+    try {
+      const response = await fetch(`${this.BASE_URL}/api/sessions/init`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          contentSessionId,
+          project,
+          prompt,
+          platformSource: PLATFORM_SOURCE
+        })
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  static async sendObservation(contentSessionId, toolName, toolInput, toolResponse, cwd) {
+    try {
+      await fetch(`${this.BASE_URL}/api/sessions/observations`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          contentSessionId,
+          tool_name: toolName,
+          tool_input: toolInput,
+          tool_response: toolResponse,
+          cwd,
+          platformSource: PLATFORM_SOURCE
+        })
+      });
+    } catch {}
+  }
+  static async summarize(contentSessionId, lastUserMessage, lastAssistantMessage) {
+    try {
+      await fetch(`${this.BASE_URL}/api/sessions/summarize`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          contentSessionId,
+          last_user_message: lastUserMessage,
+          last_assistant_message: lastAssistantMessage,
+          platformSource: PLATFORM_SOURCE
+        })
+      });
+    } catch {}
+  }
+  static async completeSession(contentSessionId) {
+    try {
+      await fetch(`${this.BASE_URL}/api/sessions/complete`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ contentSessionId, platformSource: PLATFORM_SOURCE })
+      });
+    } catch {}
+  }
+  static async getContext(project) {
+    try {
+      const response = await fetch(`${this.BASE_URL}/api/context/inject?project=${encodeURIComponent(project)}`);
+      if (!response.ok) {
+        return null;
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        return extractTextContent(await response.json());
+      }
+      const text = await response.text();
+      return text.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  static async timeline(options) {
+    try {
+      const params = new URLSearchParams({ project: options.project });
+      if (options.anchor !== undefined) {
+        params.set("anchor", String(options.anchor));
+      }
+      if (options.query) {
+        params.set("query", options.query);
+      }
+      if (options.depthBefore !== undefined) {
+        params.set("depth_before", String(options.depthBefore));
+      }
+      if (options.depthAfter !== undefined) {
+        params.set("depth_after", String(options.depthAfter));
+      }
+      const response = await fetch(`${this.BASE_URL}/api/timeline?${params.toString()}`);
+      if (!response.ok) {
+        return "";
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        return extractTextContent(await response.json()) || "";
+      }
+      const text = await response.text();
+      return text.trim();
+    } catch {
+      return "";
+    }
+  }
+  static async getObservations(ids, project) {
+    try {
+      const body = { ids };
+      if (project) {
+        body["project"] = project;
+      }
+      const response = await fetch(`${this.BASE_URL}/api/observations/batch`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        return "";
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        const payload = await response.json();
+        if (Array.isArray(payload)) {
+          return payload.length ? JSON.stringify(payload, null, 2) : "";
+        }
+        return extractTextContent(payload) || "";
+      }
+      const text = await response.text();
+      return text.trim();
+    } catch {
+      return "";
+    }
+  }
+  static async getStats() {
+    try {
+      const [statsRes, processingRes] = await Promise.all([
+        fetch(`${this.BASE_URL}/api/stats`),
+        fetch(`${this.BASE_URL}/api/processing-status`)
+      ]);
+      if (!statsRes.ok) {
+        return null;
+      }
+      const stats = await statsRes.json();
+      const processing = processingRes.ok ? await processingRes.json() : undefined;
+      return { database: stats.database, processing };
+    } catch {
+      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 });
+      if (limit !== undefined) {
+        params.set("limit", String(limit));
+      }
+      const response = await fetch(`${this.BASE_URL}/api/search?${params.toString()}`);
+      if (!response.ok) {
+        return "";
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        return extractTextContent(await response.json()) || "";
+      }
+      const text = await response.text();
+      return text.trim();
+    } catch {
+      return "";
+    }
+  }
+}
+
+// src/tui.ts
+var POLL_INTERVAL_MS = 5000;
+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) {
+  const decoded = decodeEntities(value);
+  return decoded.length <= LABEL_MAX ? decoded : `${decoded.slice(0, LABEL_MAX - 1)}\u2026`;
+}
+function formatCount(value) {
+  if (value === null) {
+    return "-";
+  }
+  return value >= 1e4 ? `${(value / 1000).toFixed(1)}k` : String(value);
+}
+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({ flexDirection: "column", paddingTop: 1 }, [
+      header,
+      ...collapsed ? [] : [box({ flexDirection: "column", paddingLeft: 2 }, expandedRows(view, theme))]
+    ])
+  ];
+}
+function viewKey(view) {
+  return JSON.stringify(view);
+}
+function readCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+async function readMemView(project, collapsed) {
+  const stats = await WorkerClient.getStats();
+  if (!stats) {
+    return {
+      healthy: false,
+      project,
+      observations: null,
+      sessions: null,
+      summaries: null,
+      queueDepth: null,
+      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,
+    observations: readCount(stats.database?.observations),
+    sessions: readCount(stats.database?.sessions),
+    summaries: readCount(stats.database?.summaries),
+    queueDepth: readCount(stats.processing?.queueDepth),
+    isProcessing: stats.processing?.isProcessing === true,
+    recentSummaries,
+    recentObservations
+  };
+}
+function materializeNode(node, solid) {
+  const element = solid.createElement(node.kind);
+  for (const [name, value] of Object.entries(node.props)) {
+    solid.setProp(element, name, value);
+  }
+  if (node.kind === "text") {
+    solid.insert(element, node.text ?? "");
+  }
+  for (const child of node.children ?? []) {
+    solid.insert(element, materializeNode(child, solid));
+  }
+  return element;
+}
+function materialize(nodes, solid) {
+  const root = solid.createElement("box");
+  solid.setProp(root, "flexDirection", "column");
+  for (const node of nodes) {
+    solid.insert(root, materializeNode(node, solid));
+  }
+  return root;
+}
+function projectNameFromDirectory(directory) {
+  return directory.split(/[\\/]/).findLast(Boolean) || "unknown-project";
+}
+var tuiModule = {
+  id: "opencode-claude-mem:tui",
+  tui: async (api) => {
+    const solid = await import("@opentui/solid").catch(() => null);
+    if (!solid) {
+      return;
+    }
+    const project = projectNameFromDirectory(String(api.state?.path?.directory ?? ""));
+    let collapsed = true;
+    let currentView = await readMemView(project, collapsed);
+    let currentKey = viewKey(currentView);
+    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) {
+        currentView = nextView;
+        currentKey = nextKey;
+        api.renderer.requestRender();
+      }
+    };
+    const onToggle = () => {
+      collapsed = !collapsed;
+      api.renderer.requestRender();
+      refresh().catch(() => {});
+    };
+    api.slots.register({
+      order: 910,
+      slots: {
+        sidebar_content: () => materialize(buildMemNodes(currentView, api.theme.current, collapsed, onToggle), solid)
+      }
+    });
+    api.renderer.requestRender();
+    const schedule = () => {
+      timer = setTimeout(tick, POLL_INTERVAL_MS);
+    };
+    const tick = async () => {
+      if (disposed || inFlight) {
+        if (!disposed) {
+          schedule();
+        }
+        return;
+      }
+      inFlight = true;
+      try {
+        await refresh();
+      } catch {} finally {
+        inFlight = false;
+        if (!disposed) {
+          schedule();
+        }
+      }
+    };
+    schedule();
+    api.lifecycle.onDispose(() => {
+      disposed = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+    });
+  }
+};
+var tui_default = tuiModule;
+export {
+  viewKey,
+  readMemView,
+  tui_default as default,
+  buildMemNodes
+};

package/dist/worker-client.d.ts

@@ -64,5 +64,51 @@ export declare class WorkerClient {
      * Uses /api/context/inject which returns rich markdown with observations + session summaries.
      */
     static getContext(project: string): Promise<string | null>;
+    /**
+     * Timeline: get chronological context around an observation anchor or query.
+     * Mirrors the upstream MCP `timeline` tool (GET /api/timeline).
+     */
+    static timeline(options: {
+        project: string;
+        anchor?: number;
+        query?: string;
+        depthBefore?: number;
+        depthAfter?: number;
+    }): Promise<string>;
+    /**
+     * Fetch full observation details by IDs.
+     * Mirrors the upstream MCP `get_observations` tool (POST /api/observations/batch).
+     */
+    static getObservations(ids: number[], project?: string): Promise<string>;
+    /**
+     * Fetch worker + database stats plus processing status for the sidebar view.
+     * Combines GET /api/stats and GET /api/processing-status; null when offline.
+     */
+    static getStats(): Promise<{
+        database?: {
+            observations?: number;
+            sessions?: number;
+            summaries?: number;
+        };
+        processing?: {
+            isProcessing?: boolean;
+            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.3.3",
+  "version": "0.4.1",
   "description": "OpenCode plugin for Claude-Mem persistent memory system",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,10 +16,14 @@
     "./server": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "import": "./dist/tui.js"
     }
   },
   "scripts": {
-    "build": "bun build src/index.ts --outfile dist/index.js --target bun --format esm && 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 && tsc -p tsconfig.build.json --emitDeclarationOnly",
     "dev": "tsc --watch",
     "clean": "rm -rf dist",
     "lint": "oxlint",