@ephemushroom/opencode-claude-mem 0.4.4 → 0.6.0

package/dist/cli.js

@@ -0,0 +1,743 @@
+// @bun
+// src/worker-client.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { spawn } from "child_process";
+
+// src/shared.ts
+var MAX_OBSERVATION_BYTES = 24 * 1024;
+var META_TOOLS = new Set([
+  "askuserquestion",
+  "getmcpresource",
+  "listmcpresourcestool",
+  "listmcptools",
+  "mem-get-observations",
+  "mem-search",
+  "mem-timeline",
+  "skill",
+  "slashcommand",
+  "todowrite"
+]);
+function stripTaggedContent(text) {
+  let result = "";
+  let offset = 0;
+  const stack = [];
+  for (const match of text.matchAll(/<(\/?)(private|claude-mem-context)\b[^>]*>/gi)) {
+    if (stack.length === 0) {
+      result += text.slice(offset, match.index);
+    }
+    const name = match[2].toLowerCase();
+    if (match[1] === "/") {
+      if (stack.at(-1) === name) {
+        stack.pop();
+      }
+    } else {
+      stack.push(name);
+    }
+    offset = match.index + match[0].length;
+  }
+  if (stack.length === 0) {
+    result += text.slice(offset);
+  }
+  return result.trim();
+}
+
+// src/worker-client.ts
+var HEALTH_TIMEOUT_MS = 1000;
+var WRITE_TIMEOUT_MS = 1e4;
+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 buildSearchParams(options) {
+  const params = new URLSearchParams;
+  const entries = [
+    ["query", options.query ?? ""],
+    ["limit", options.limit],
+    ["project", options.project],
+    ["platformSource", options.platformSource],
+    ["type", options.type],
+    ["obs_type", options.obs_type],
+    ["dateStart", options.dateStart],
+    ["dateEnd", options.dateEnd],
+    ["offset", options.offset],
+    ["orderBy", options.orderBy]
+  ];
+  for (const [key, value] of entries) {
+    if (value !== undefined) {
+      params.set(key, String(value));
+    }
+  }
+  return params;
+}
+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 text = content.map((part) => {
+      if (!isRecord(part) || part["type"] !== "text" || typeof part["text"] !== "string") {
+        return "";
+      }
+      return part["text"];
+    }).filter(Boolean).join(`
+`).trim();
+    return text || 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 response = await fetch(`${this.BASE_URL}/api/health`, {
+        signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  static async ensureRunning() {
+    await this.tryAutoStart();
+    return this.isHealthy();
+  }
+  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",
+        signal: AbortSignal.timeout(WRITE_TIMEOUT_MS),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          contentSessionId,
+          project,
+          prompt,
+          platformSource: PLATFORM_SOURCE
+        })
+      });
+      if (!response.ok) {
+        return null;
+      }
+      const value = await response.json();
+      if (!isRecord(value) || typeof value.sessionDbId !== "number" || typeof value.promptNumber !== "number" || !Number.isFinite(value.sessionDbId) || !Number.isFinite(value.promptNumber)) {
+        return null;
+      }
+      return {
+        sessionDbId: value.sessionDbId,
+        promptNumber: value.promptNumber,
+        skipped: value.skipped === true,
+        reason: typeof value.reason === "string" ? value.reason : undefined
+      };
+    } catch {
+      return null;
+    }
+  }
+  static async sendObservation(contentSessionId, toolName, toolInput, toolResponse, cwd, toolUseId) {
+    try {
+      const response = await fetch(`${this.BASE_URL}/api/sessions/observations`, {
+        method: "POST",
+        signal: AbortSignal.timeout(WRITE_TIMEOUT_MS),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          contentSessionId,
+          tool_name: toolName,
+          tool_input: toolInput,
+          tool_response: toolResponse,
+          cwd,
+          platformSource: PLATFORM_SOURCE,
+          tool_use_id: toolUseId
+        })
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  static async summarize(contentSessionId, lastUserMessage, lastAssistantMessage, metadata = {}) {
+    try {
+      const response = await fetch(`${this.BASE_URL}/api/sessions/summarize`, {
+        method: "POST",
+        signal: AbortSignal.timeout(WRITE_TIMEOUT_MS),
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          contentSessionId,
+          last_user_message: stripTaggedContent(lastUserMessage),
+          last_assistant_message: stripTaggedContent(lastAssistantMessage),
+          platformSource: PLATFORM_SOURCE,
+          observedModel: metadata.observedModel,
+          observedBilling: metadata.observedBilling
+        })
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  static async getContext(project) {
+    try {
+      const response = await fetch(`${this.BASE_URL}/api/context/inject?project=${encodeURIComponent(project)}`, { signal: AbortSignal.timeout(2000) });
+      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(options) {
+    try {
+      const params = buildSearchParams(options);
+      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/sidebar-model.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
+  };
+}
+
+// node_modules/@opencode-ai/plugin-v2/dist/tui/plugin.js
+function define(plugin) {
+  return plugin;
+}
+
+// src/cli.ts
+var REFRESH_EVENTS = ["session.created", "session.execution.succeeded"];
+function emptyView(project) {
+  return {
+    healthy: false,
+    project,
+    observations: null,
+    sessions: null,
+    summaries: null,
+    queueDepth: null,
+    isProcessing: false,
+    recentSummaries: [],
+    recentObservations: []
+  };
+}
+var cli_default = define({
+  id: "claude-mem.tui",
+  setup: async (ctx) => {
+    const solid = await import("@opentui/solid").catch(() => null);
+    if (!solid) {
+      return;
+    }
+    const project = String(ctx.location?.directory ?? process.cwd()).split(/[\\/]/).filter(Boolean).findLast(Boolean) ?? "unknown-project";
+    const [state, setState] = ctx.storage.memory("claude-mem.sidebar", {
+      initial: { collapsed: true, view: emptyView(project) }
+    });
+    let disposed = false;
+    let inFlight = false;
+    let refreshPending = false;
+    let timer = null;
+    const refresh = async () => {
+      if (disposed) {
+        return;
+      }
+      if (inFlight) {
+        refreshPending = true;
+        return;
+      }
+      inFlight = true;
+      try {
+        do {
+          refreshPending = false;
+          const { collapsed } = state;
+          const next = await readMemView(project, collapsed);
+          if (disposed) {
+            return;
+          }
+          if (collapsed === state.collapsed) {
+            setState((draft) => {
+              if (viewKey(draft.view) !== viewKey(next)) {
+                draft.view = next;
+              }
+            });
+          }
+        } while (refreshPending);
+      } catch {} finally {
+        inFlight = false;
+      }
+    };
+    const onToggle = () => {
+      if (disposed) {
+        return;
+      }
+      setState((draft) => {
+        draft.collapsed = !draft.collapsed;
+      });
+      refresh().catch(() => {});
+    };
+    const disposeSlot = ctx.ui.slot({
+      append: "sidebar.content",
+      render: () => materialize(() => buildMemNodes(state.view, themeFromResolved(ctx.theme), state.collapsed, onToggle), solid)
+    });
+    const disposeEvents = REFRESH_EVENTS.map((type) => ctx.data.on(type, () => {
+      refresh().catch(() => {});
+    }));
+    const schedule = () => {
+      timer = setTimeout(tick, POLL_INTERVAL_MS);
+    };
+    const tick = async () => {
+      if (disposed) {
+        return;
+      }
+      await refresh();
+      if (!disposed) {
+        schedule();
+      }
+    };
+    refresh().catch(() => {}).finally(() => {
+      if (disposed) {
+        return;
+      }
+      schedule();
+      if (!state.view.healthy) {
+        ctx.ui.toast.show({
+          title: "Claude-Mem",
+          message: "Worker offline \u2014 start Claude Code or run bunx claude-mem start",
+          variant: "warning",
+          duration: 5000
+        });
+      }
+    }).catch(() => {});
+    return () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      disposeSlot();
+      for (const dispose of disposeEvents) {
+        dispose();
+      }
+    };
+  }
+});
+function themeFromResolved(resolved) {
+  const { text } = resolved;
+  return {
+    text: text.default,
+    textMuted: text.subdued,
+    info: text.action.primary.default,
+    success: text.feedback.success.default,
+    warning: text.feedback.warning.default,
+    error: text.feedback.error.default,
+    borderSubtle: resolved.border.default
+  };
+}
+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");
+  solid.insert(root, () => nodes().map((node) => materializeNode(node, solid)));
+  return root;
+}
+export {
+  cli_default as default
+};