@ephemushroom/opencode-claude-mem 0.4.4 → 0.6.0

package/dist/memory-options.d.ts

@@ -0,0 +1,12 @@
+export interface InjectionOptions {
+    readonly enabled: boolean;
+    readonly limit: number;
+    readonly maxChars: number;
+    readonly timeoutMs: number;
+}
+export interface MemoryOptions {
+    readonly semanticInjection: InjectionOptions;
+    readonly fileContext: InjectionOptions;
+}
+export declare function parseMemoryOptions(options: unknown, env: Readonly<Record<string, string | undefined>>, settings: unknown): MemoryOptions;
+export declare function resolveMemoryOptions(options: unknown): MemoryOptions;

package/dist/memory-session.d.ts

@@ -0,0 +1,22 @@
+import type { MemoryOptions } from './memory-options';
+import type { MemoryTurn } from './memory-turn';
+import { MemoryWorker } from './memory-worker';
+export declare class MemorySessions {
+    private readonly sessions;
+    private readonly deleted;
+    private readonly options;
+    private readonly worker;
+    constructor(options: MemoryOptions, worker?: typeof MemoryWorker);
+    private state;
+    select(session: string, turn: MemoryTurn): boolean;
+    hasTurn(session: string): boolean;
+    hasMessage(session: string, id: string): boolean;
+    isDeleted(session: string): boolean;
+    canCapture(session: string): boolean;
+    register(session: string, project: string): Promise<boolean>;
+    semantic(session: string, project: string): Promise<string>;
+    context(session: string, project: string): Promise<string | null>;
+    invalidate(session: string): void;
+    delete(session: string): void;
+    clear(): void;
+}

package/dist/memory-turn.d.ts

@@ -0,0 +1,10 @@
+export interface MemoryTurn {
+    readonly id: string;
+    readonly text: string;
+    readonly capture: boolean;
+    readonly semantic: boolean;
+}
+export declare function memoryTurn(id: string, text: string, media?: boolean): MemoryTurn;
+/** Only consumed session context, never the admission/inbox list. */
+export declare function deliveredTurn(messages: readonly unknown[]): MemoryTurn | undefined;
+export declare function resumedV1Turn(messages: unknown): MemoryTurn | undefined;

package/dist/memory-worker.d.ts

@@ -0,0 +1,21 @@
+import type { InjectionOptions } from './memory-options';
+import { z } from 'zod';
+declare const fileResponse: z.ZodObject<{
+    observations: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodNullable<z.ZodString>;
+        type: z.ZodString;
+        created_at_epoch: z.ZodNumber;
+        memory_session_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export type FileObservation = z.infer<typeof fileResponse>['observations'][number];
+export declare class MemoryWorker {
+    private static readonly baseUrl;
+    private static json;
+    static save(input: unknown, project: string): Promise<string>;
+    static semantic(prompt: string, project: string, options: InjectionOptions): Promise<string>;
+    static byFile(paths: readonly string[], project: string, options: InjectionOptions): Promise<readonly FileObservation[]>;
+}
+export {};

package/dist/package-server.d.ts

@@ -0,0 +1,7 @@
+export { ClaudeMemPlugin } from './index';
+declare const _default: {
+    id: string;
+    server: import("@opencode-ai/plugin").Plugin;
+    setup: (context: import("@opencode-ai/plugin-v2/promise/plugin").Context) => Promise<import("@opencode-ai/plugin-v2/promise/plugin").Cleanup | void> | import("@opencode-ai/plugin-v2/promise/plugin").Cleanup | void;
+};
+export default _default;

package/dist/package-server.js

@@ -0,0 +1,10 @@
+// @bun
+// src/package-server.ts
+import v1 from "./index";
+import v2 from "./v2";
+import { ClaudeMemPlugin } from "./index";
+var package_server_default = { id: v2.id, server: v1.server, setup: v2.setup };
+export {
+  ClaudeMemPlugin,
+  package_server_default as default
+};

package/dist/package-tui.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    id: string;
+    tui: (api: any) => Promise<void>;
+    setup: (context: import("@opencode-ai/plugin-v2/tui/context").Context) => Promise<import("@opencode-ai/plugin-v2/tui/plugin").Cleanup | void> | import("@opencode-ai/plugin-v2/tui/plugin").Cleanup | void;
+};
+export default _default;

package/dist/package-tui.js

@@ -0,0 +1,8 @@
+// @bun
+// src/package-tui.ts
+import v1 from "./tui.js";
+import v2 from "./cli.js";
+var package_tui_default = { id: v2.id, tui: v1.tui, setup: v2.setup };
+export {
+  package_tui_default as default
+};

package/dist/shared.d.ts

@@ -0,0 +1,14 @@
+export declare const MAX_OBSERVATION_BYTES: number;
+export declare const MAX_TAG_REPLACEMENTS = 100;
+export declare const META_TOOLS: Set<string>;
+export declare function stripTaggedContent(text: string): string;
+export declare function sanitizeObservationValue(value: unknown): unknown;
+export declare function truncateUtf8Bytes(text: string, maxBytes: number): string;
+export declare function shouldSkipObservationTool(toolName: string): boolean;
+export declare function normalizeToolOutput(output: unknown): string;
+/**
+ * Extract text content from message parts.
+ * Parts can be TextPart, ToolCallPart, etc. We only want text.
+ * Skips synthetic/ignored parts to match what is shown to the user.
+ */
+export declare function extractTextFromParts(parts: any[]): string;

package/dist/sidebar-model.d.ts

@@ -0,0 +1,50 @@
+export declare const POLL_INTERVAL_MS = 5000;
+export declare const OBSERVATION_TYPE_ICONS: Record<string, string>;
+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;
+    }[];
+}
+export interface ViewNode {
+    readonly kind: 'box' | 'text';
+    readonly props: Record<string, unknown>;
+    readonly children?: readonly ViewNode[];
+    readonly text?: string;
+}
+export interface Theme {
+    readonly text: unknown;
+    readonly textMuted: unknown;
+    readonly info: unknown;
+    readonly success: unknown;
+    readonly warning: unknown;
+    readonly error: unknown;
+    readonly borderSubtle: unknown;
+}
+export declare function box(props: Record<string, unknown>, children: readonly ViewNode[]): ViewNode;
+export declare function text(props: Record<string, unknown>, value: string): ViewNode;
+export declare function decodeEntities(value: string): string;
+export declare function truncate(value: string): string;
+export declare function formatCount(value: number | null): string;
+export declare function summaryLine(view: MemSidebarView): {
+    label: string;
+    tone: 'ok' | 'warn' | 'err';
+};
+export declare function toneColor(tone: 'ok' | 'warn' | 'err', theme: Theme): unknown;
+export declare function bulletRow(icon: string, iconColor: unknown, label: string, theme: Theme): ViewNode;
+export declare function expandedRows(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, collapsed: boolean): Promise<MemSidebarView>;

package/dist/tui-registration.d.ts

@@ -7,3 +7,10 @@ export type TuiRegistrationResult = 'added' | 'already-present' | 'no-server-ent
  * target instead of being replaced by a regular file.
  */
 export declare function ensureTuiPluginEntry(): TuiRegistrationResult;
+/**
+ * V2 self-heal: register the V2 CLI entry in `~/.config/opencode/cli.json`
+ * (the V2 CLI/TUI config file) so the Memory sidebar loads in the V2 TUI
+ * without manual configuration. The CLI writes strict JSON (2-space indent),
+ * so a comment-bearing file is left untouched ('malformed').
+ */
+export declare function ensureCliPluginEntry(): TuiRegistrationResult;

package/dist/tui.d.ts

@@ -1,39 +1,3 @@
-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>;

package/dist/tui.js

@@ -1,12 +1,51 @@
 // @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";
+
+// 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";
@@ -92,14 +131,14 @@ function extractTextContent(value) {
     return content.trim() || null;
   }
   if (Array.isArray(content)) {
-    const text2 = content.map((part) => {
+    const text = content.map((part) => {
       if (!isRecord(part) || part["type"] !== "text" || typeof part["text"] !== "string") {
         return "";
       }
       return part["text"];
     }).filter(Boolean).join(`
 `).trim();
-    return text2 || null;
+    return text || null;
   }
   const text = JSON.stringify(value, null, 2);
   return text === "{}" || text === "null" ? null : text;
@@ -110,20 +149,17 @@ class WorkerClient {
   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
+        signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS)
       });
-      clearTimeout(timeoutId);
       return response.ok;
     } catch {
       return false;
     }
   }
   static async ensureRunning() {
-    const result = await this.tryAutoStart();
-    return result === "already-running" || result === "started";
+    await this.tryAutoStart();
+    return this.isHealthy();
   }
   static tryAutoStart() {
     if (!this.autoStartPromise) {
@@ -191,6 +227,7 @@ class WorkerClient {
     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,
@@ -202,15 +239,25 @@ class WorkerClient {
       if (!response.ok) {
         return null;
       }
-      return await response.json();
+      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) {
+  static async sendObservation(contentSessionId, toolName, toolInput, toolResponse, cwd, toolUseId) {
     try {
-      await fetch(`${this.BASE_URL}/api/sessions/observations`, {
+      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,
@@ -218,37 +265,38 @@ class WorkerClient {
           tool_input: toolInput,
           tool_response: toolResponse,
           cwd,
-          platformSource: PLATFORM_SOURCE
+          platformSource: PLATFORM_SOURCE,
+          tool_use_id: toolUseId
         })
       });
-    } catch {}
+      return response.ok;
+    } catch {
+      return false;
+    }
   }
-  static async summarize(contentSessionId, lastUserMessage, lastAssistantMessage) {
+  static async summarize(contentSessionId, lastUserMessage, lastAssistantMessage, metadata = {}) {
     try {
-      await fetch(`${this.BASE_URL}/api/sessions/summarize`, {
+      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: lastUserMessage,
-          last_assistant_message: lastAssistantMessage,
-          platformSource: PLATFORM_SOURCE
+          last_user_message: stripTaggedContent(lastUserMessage),
+          last_assistant_message: stripTaggedContent(lastAssistantMessage),
+          platformSource: PLATFORM_SOURCE,
+          observedModel: metadata.observedModel,
+          observedBilling: metadata.observedBilling
         })
       });
-    } 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 {}
+      return response.ok;
+    } catch {
+      return false;
+    }
   }
   static async getContext(project) {
     try {
-      const response = await fetch(`${this.BASE_URL}/api/context/inject?project=${encodeURIComponent(project)}`);
+      const response = await fetch(`${this.BASE_URL}/api/context/inject?project=${encodeURIComponent(project)}`, { signal: AbortSignal.timeout(2000) });
       if (!response.ok) {
         return null;
       }
@@ -399,7 +447,7 @@ class WorkerClient {
   }
 }
 
-// src/tui.ts
+// src/sidebar-model.ts
 var POLL_INTERVAL_MS = 5000;
 var LABEL_MAX = 40;
 var RECENT_SUMMARIES = 3;
@@ -537,6 +585,8 @@ async function readMemView(project, collapsed) {
     recentObservations
   };
 }
+
+// src/tui.ts
 async function loadSolidCore() {
   try {
     const mod = await import("solid-js");
@@ -652,8 +702,5 @@ var tuiModule = {
 };
 var tui_default = tuiModule;
 export {
-  viewKey,
-  readMemView,
-  tui_default as default,
-  buildMemNodes
+  tui_default as default
 };

package/dist/v2.d.ts

@@ -0,0 +1,22 @@
+/**
+ * OpenCode V2 plugin for Claude-Mem.
+ *
+ * V2 is a breaking API change from V1 — plugins are `Plugin.define({ id,
+ * setup })` modules with a server-like context instead of a `{ server }`
+ * module of hook handlers. This entrypoint is published under the package's
+ * `./v2` export; V1 users keep loading the default export (see src/index.ts).
+ * Both entrypoints are thin adapters over the same WorkerClient + shared
+ * helpers, so V1 and V2 can coexist and talk to the same Claude-Mem worker.
+ *
+ * V2 API mapping (vs V1):
+ * - `experimental.chat.system.transform` → `ctx.session.hook('context')` (push
+ *   a SystemPart into `event.system`)
+ * - `tool.execute.after` → `ctx.tool.hook('execute.after')`
+ * - `tool` definitions → `ctx.tool.transform((tools) => tools.add(...))`
+ * - `event` lifecycle → `ctx.event.subscribe()` stream
+ * - Assistant text capture uses `session.text.ended` events (the event carries
+ *   the complete text — no debounced re-fetch needed like V1's message.updated)
+ * - Summarization fires on `session.execution.succeeded` (V1's session.idle)
+ */
+declare const _default: import("@opencode-ai/plugin-v2/promise/plugin").Plugin;
+export default _default;