@ephemushroom/opencode-claude-mem 0.4.3 → 0.5.0

package/dist/v2.js

@@ -0,0 +1,992 @@
+// @bun
+// node_modules/@opencode-ai/plugin-v2/dist/promise/plugin.js
+function define(plugin) {
+  return plugin;
+}
+
+// src/shared.ts
+var MAX_OBSERVATION_BYTES = 24 * 1024;
+var MAX_TAG_REPLACEMENTS = 100;
+var META_TOOLS = new Set([
+  "askuserquestion",
+  "getmcpresource",
+  "listmcpresourcestool",
+  "listmcptools",
+  "mem-get-observations",
+  "mem-search",
+  "mem-timeline",
+  "skill",
+  "slashcommand",
+  "todowrite"
+]);
+var PRIVATE_TAG_REGEX = /<private>[\s\S]*?<\/private>/g;
+var CONTEXT_TAG_REGEX = /<claude-mem-context>[\s\S]*?<\/claude-mem-context>/g;
+function stripTaggedContent(text) {
+  if (!text) {
+    return text;
+  }
+  let result = text;
+  let replacements = 0;
+  while (replacements < MAX_TAG_REPLACEMENTS && PRIVATE_TAG_REGEX.test(result)) {
+    PRIVATE_TAG_REGEX.lastIndex = 0;
+    result = result.replace(PRIVATE_TAG_REGEX, "");
+    replacements++;
+  }
+  PRIVATE_TAG_REGEX.lastIndex = 0;
+  while (replacements < MAX_TAG_REPLACEMENTS && CONTEXT_TAG_REGEX.test(result)) {
+    CONTEXT_TAG_REGEX.lastIndex = 0;
+    result = result.replace(CONTEXT_TAG_REGEX, "");
+    replacements++;
+  }
+  CONTEXT_TAG_REGEX.lastIndex = 0;
+  return result.trim();
+}
+function sanitizeObservationValue(value) {
+  if (typeof value === "string") {
+    return stripTaggedContent(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeObservationValue(item));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitizeObservationValue(item)]));
+  }
+  return value;
+}
+function truncateUtf8Bytes(text, maxBytes) {
+  const encoder = new TextEncoder;
+  if (encoder.encode(text).length <= maxBytes) {
+    return text;
+  }
+  const suffix = `
+[truncated]`;
+  const suffixBytes = encoder.encode(suffix).length;
+  const budget = Math.max(maxBytes - suffixBytes, 0);
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    const candidate = text.slice(0, mid);
+    if (encoder.encode(candidate).length <= budget) {
+      low = mid;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return `${text.slice(0, low)}${suffix}`;
+}
+function shouldSkipObservationTool(toolName) {
+  if (!toolName) {
+    return true;
+  }
+  const normalizedName = toolName.toLowerCase().replaceAll("_", "-");
+  if (normalizedName.includes("mcp-search") || /(?:^|[-.])mem-(?:search|timeline|get-observations)$/.test(normalizedName)) {
+    return true;
+  }
+  return META_TOOLS.has(normalizedName);
+}
+function normalizeToolOutput(output) {
+  if (typeof output === "string") {
+    return output;
+  }
+  if (output === undefined || output === null) {
+    return "";
+  }
+  try {
+    return JSON.stringify(output);
+  } catch {
+    return String(output);
+  }
+}
+function extractTextFromParts(parts) {
+  if (!parts || !Array.isArray(parts)) {
+    return "";
+  }
+  return parts.filter((p) => p && p.type === "text" && typeof p.text === "string" && !p.synthetic && !p.ignored).map((p) => p.text).join(`
+`).trim();
+}
+
+// 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 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;
+      }
+      return await response.json();
+    } 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: lastUserMessage,
+          last_assistant_message: 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)}`);
+      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/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";
+var SIDEBAR_ENTRIES = [PACKAGE_NAME, `${PACKAGE_NAME}/cli`, `${PACKAGE_NAME}/tui`];
+function getConfigDir() {
+  const custom = process.env["OPENCODE_CONFIG_DIR"]?.trim();
+  return custom || 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 isCliEntry(entry) {
+  if (typeof entry === "string") {
+    return true;
+  }
+  if (typeof entry !== "object" || entry === null || !("package" in entry)) {
+    return false;
+  }
+  return typeof entry.package === "string" && (!("options" in entry) || typeof entry.options === "object" && entry.options !== null && !Array.isArray(entry.options));
+}
+function v2PluginEntries(config) {
+  const { plugins } = config;
+  if (plugins === undefined) {
+    return [];
+  }
+  return Array.isArray(plugins) && plugins.every(isCliEntry) ? plugins : null;
+}
+function ensureCliPluginEntry() {
+  try {
+    const configDir = getConfigDir();
+    const cliJsonPath = join2(configDir, "cli.json");
+    let config = {};
+    if (existsSync2(cliJsonPath)) {
+      const parsed = readJson(cliJsonPath);
+      if (!parsed) {
+        return "malformed";
+      }
+      config = parsed;
+    }
+    const plugins = v2PluginEntries(config);
+    if (!plugins) {
+      return "malformed";
+    }
+    if (plugins.some((entry) => {
+      const specifier = typeof entry === "string" ? entry : entry.package;
+      return SIDEBAR_ENTRIES.some((name) => specifier === name || specifier.startsWith(`${name}@`));
+    })) {
+      return "already-present";
+    }
+    mkdirSync(configDir, { recursive: true });
+    const next = { ...config, plugins: [...plugins, PACKAGE_NAME] };
+    writeFileSync(cliJsonPath, `${JSON.stringify(next, null, 2)}
+`);
+    return "added";
+  } catch {
+    return "failed";
+  }
+}
+
+// src/v2.ts
+var EVENT_RETRY_DELAY_MS = 1e4;
+var v2_default = define({
+  id: "claude-mem",
+  setup: async (ctx) => {
+    ensureCliPluginEntry();
+    const controller = new AbortController;
+    const initializedSessions = new Set;
+    const sessionInits = new Map;
+    const contextCache = new Map;
+    const sessionDirs = new Map;
+    const sessionUserTexts = new Map;
+    const sessionAssistantTexts = new Map;
+    const sessionModels = new Map;
+    const defaultDirectory = ctx.location.directory;
+    async function checkWorker() {
+      return !controller.signal.aborted && await WorkerClient.ensureRunning();
+    }
+    async function loadSessionLocation(sessionId) {
+      if (sessionDirs.has(sessionId)) {
+        return true;
+      }
+      try {
+        const session = await ctx.session.get({ sessionID: sessionId });
+        if (controller.signal.aborted || session.location.directory !== defaultDirectory) {
+          return false;
+        }
+        sessionDirs.set(sessionId, session.location.directory);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function projectNameFromDirectory(directory) {
+      return directory.split(/[\\/]/).findLast(Boolean) || "unknown-project";
+    }
+    function getProjectName(sessionId) {
+      return projectNameFromDirectory(sessionDirs.get(sessionId) || defaultDirectory);
+    }
+    async function ensureSessionInit(sessionId, prompt) {
+      if (initializedSessions.has(sessionId)) {
+        return true;
+      }
+      const existing = sessionInits.get(sessionId);
+      if (existing) {
+        return existing;
+      }
+      const pending = (async () => {
+        if (!await checkWorker() || !await loadSessionLocation(sessionId)) {
+          return false;
+        }
+        const result = await WorkerClient.sessionInit(sessionId, getProjectName(sessionId), prompt || "SESSION_START");
+        if (!result || controller.signal.aborted || !sessionInits.has(sessionId)) {
+          return false;
+        }
+        initializedSessions.add(sessionId);
+        return true;
+      })();
+      sessionInits.set(sessionId, pending);
+      try {
+        return await pending;
+      } finally {
+        if (sessionInits.get(sessionId) === pending) {
+          sessionInits.delete(sessionId);
+        }
+      }
+    }
+    async function getCachedContext(sessionId) {
+      if (!contextCache.has(sessionId)) {
+        const context = await WorkerClient.getContext(getProjectName(sessionId));
+        if (context !== null && !controller.signal.aborted && sessionDirs.has(sessionId)) {
+          contextCache.set(sessionId, context);
+        }
+      }
+      return contextCache.get(sessionId) ?? null;
+    }
+    async function sendObservation(sessionId, toolName, toolInput, toolResponse, toolUseId) {
+      if (!await ensureSessionInit(sessionId)) {
+        return;
+      }
+      try {
+        await WorkerClient.sendObservation(sessionId, toolName, toolInput, toolResponse, sessionDirs.get(sessionId) || defaultDirectory, toolUseId);
+      } catch {}
+    }
+    function extractLastUserText(messages) {
+      if (!Array.isArray(messages)) {
+        return "";
+      }
+      for (const message of messages.toReversed()) {
+        if (message && typeof message === "object" && "role" in message && message.role === "user" && "content" in message && Array.isArray(message.content)) {
+          const text = extractTextFromParts(message.content);
+          if (text) {
+            return text;
+          }
+        }
+      }
+      return "";
+    }
+    function normalizeToolResult(result) {
+      if (typeof result === "string") {
+        return result;
+      }
+      if (!result || typeof result !== "object") {
+        return normalizeToolOutput(result);
+      }
+      const content = "content" in result ? result.content : undefined;
+      if (typeof content === "string") {
+        return content;
+      }
+      if (Array.isArray(content)) {
+        const text = extractTextFromParts(content);
+        if (text) {
+          return text;
+        }
+      }
+      if ("output" in result && result.output !== undefined) {
+        return normalizeToolOutput(result.output);
+      }
+      return normalizeToolOutput(result);
+    }
+    await ctx.session.hook("context", async (event) => {
+      const sessionId = event.sessionID;
+      if (!sessionId) {
+        return;
+      }
+      if (!await loadSessionLocation(sessionId)) {
+        return;
+      }
+      sessionModels.set(sessionId, event.model.id);
+      sessionUserTexts.set(sessionId, extractLastUserText(event.messages));
+      await ensureSessionInit(sessionId, sessionUserTexts.get(sessionId));
+      if (!await checkWorker()) {
+        return;
+      }
+      try {
+        const context = await getCachedContext(sessionId);
+        if (context) {
+          event.system.push({
+            type: "text",
+            text: `<claude-mem-context>
+[Claude-Mem] Memory Active. Previous Context:
+${context}
+</claude-mem-context>`
+          });
+        }
+      } catch {}
+    });
+    await ctx.tool.hook("execute.after", async (event) => {
+      const sessionId = event.sessionID;
+      if (!sessionId || shouldSkipObservationTool(event.tool)) {
+        return;
+      }
+      if (!await checkWorker()) {
+        return;
+      }
+      const sanitizedInput = sanitizeObservationValue(event.input ?? {});
+      const sanitizedOutput = truncateUtf8Bytes(stripTaggedContent(event.status === "error" ? event.error?.message ?? String(event.error ?? "") : normalizeToolResult(event.result)), MAX_OBSERVATION_BYTES);
+      await sendObservation(sessionId, event.tool, sanitizedInput, sanitizedOutput, event.id);
+    });
+    await ctx.tool.transform((tools) => {
+      tools.add({
+        name: "mem-search",
+        description: "Search Claude-Mem persistent memory. Supports query, project, platformSource, type, obs_type, dateStart, dateEnd, offset, and orderBy filters.",
+        input: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Optional semantic search query for Claude-Mem memory"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              description: "Maximum number of search results (default 20)"
+            },
+            project: { type: "string", description: "Filter by project name" },
+            platformSource: {
+              type: "string",
+              description: "Filter by platform source, such as claude or opencode"
+            },
+            type: { type: "string", description: "Filter by result type" },
+            obs_type: {
+              type: "string",
+              description: "Filter by observation type, such as feature or bugfix"
+            },
+            dateStart: {
+              type: "string",
+              description: "Start date filter in ISO 8601 or YYYY-MM-DD format"
+            },
+            dateEnd: {
+              type: "string",
+              description: "End date filter in ISO 8601 or YYYY-MM-DD format"
+            },
+            offset: { type: "integer", minimum: 0, description: "Pagination offset" },
+            orderBy: {
+              type: "string",
+              enum: ["date_desc", "date_asc", "relevance"],
+              description: "Sort order"
+            }
+          },
+          additionalProperties: false
+        },
+        options: { codemode: false },
+        execute: async (input, toolContext) => {
+          const args = input ?? {};
+          if (!await checkWorker()) {
+            return {
+              content: "Claude-Mem worker is offline. Start Claude-Mem and retry the search."
+            };
+          }
+          const result = await WorkerClient.search({
+            query: args.query,
+            limit: args.limit,
+            project: args.project ?? getProjectName(toolContext.sessionID),
+            platformSource: args.platformSource,
+            type: args.type,
+            obs_type: args.obs_type,
+            dateStart: args.dateStart,
+            dateEnd: args.dateEnd,
+            offset: args.offset,
+            orderBy: args.orderBy
+          });
+          return {
+            content: result || `No Claude-Mem results found${args.query ? ` for "${args.query}"` : ""}.`
+          };
+        }
+      });
+      tools.add({
+        name: "mem-timeline",
+        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.",
+        input: {
+          type: "object",
+          properties: {
+            anchor: {
+              type: "integer",
+              minimum: 1,
+              description: "Observation ID to center the timeline around"
+            },
+            query: {
+              type: "string",
+              description: "Query to locate the anchor automatically (used when anchor is omitted)"
+            },
+            depth_before: {
+              type: "integer",
+              minimum: 0,
+              maximum: 20,
+              description: "Items before the anchor (default 3)"
+            },
+            depth_after: {
+              type: "integer",
+              minimum: 0,
+              maximum: 20,
+              description: "Items after the anchor (default 3)"
+            }
+          },
+          additionalProperties: false
+        },
+        options: { codemode: false },
+        execute: async (input, toolContext) => {
+          const args = input ?? {};
+          if (args.anchor === undefined && !args.query) {
+            return { content: "Provide either an anchor observation ID or a query." };
+          }
+          if (!await checkWorker()) {
+            return { content: "Claude-Mem worker is offline. Start Claude-Mem and retry." };
+          }
+          const result = await WorkerClient.timeline({
+            project: getProjectName(toolContext.sessionID),
+            anchor: args.anchor,
+            query: args.query,
+            depthBefore: args.depth_before,
+            depthAfter: args.depth_after
+          });
+          return { content: result || "No Claude-Mem timeline results found." };
+        }
+      });
+      tools.add({
+        name: "mem-get-observations",
+        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.",
+        input: {
+          type: "object",
+          properties: {
+            ids: {
+              type: "array",
+              items: { type: "integer", minimum: 1 },
+              description: "Observation IDs to fetch"
+            }
+          },
+          required: ["ids"],
+          additionalProperties: false
+        },
+        options: { codemode: false },
+        execute: async (input, toolContext) => {
+          const args = input ?? {};
+          if (!await checkWorker()) {
+            return { content: "Claude-Mem worker is offline. Start Claude-Mem and retry." };
+          }
+          const result = await WorkerClient.getObservations(args.ids || [], getProjectName(toolContext.sessionID));
+          return {
+            content: result || `No Claude-Mem observations found for IDs [${(args.ids || []).join(", ")}].`
+          };
+        }
+      });
+    });
+    let aborted = false;
+    let retryTimer = undefined;
+    const subscribeAndHandleEvents = async () => {
+      try {
+        for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+          if (aborted) {
+            return;
+          }
+          try {
+            await handleEvent(event);
+          } catch {}
+        }
+      } catch {}
+      if (!aborted) {
+        retryTimer = setTimeout(() => {
+          subscribeAndHandleEvents();
+        }, EVENT_RETRY_DELAY_MS);
+      }
+    };
+    async function handleEvent(event) {
+      if (event.location && event.location.directory !== defaultDirectory) {
+        return;
+      }
+      switch (event.type) {
+        case "session.created": {
+          const { data } = event;
+          if (!data?.sessionID) {
+            return;
+          }
+          const directory = data.location?.directory;
+          if (typeof directory === "string" && directory) {
+            if (directory !== defaultDirectory) {
+              return;
+            }
+            sessionDirs.set(data.sessionID, directory);
+          }
+          contextCache.delete(data.sessionID);
+          await checkWorker();
+          return;
+        }
+        case "session.text.ended": {
+          const { data } = event;
+          const sessionId = data?.sessionID;
+          const text = data?.text;
+          if (typeof sessionId !== "string" || typeof text !== "string" || !text) {
+            return;
+          }
+          if (!await loadSessionLocation(sessionId)) {
+            return;
+          }
+          sessionAssistantTexts.set(sessionId, text);
+          if (!await checkWorker()) {
+            return;
+          }
+          const sanitized = truncateUtf8Bytes(stripTaggedContent(text), MAX_OBSERVATION_BYTES);
+          if (sanitized) {
+            await sendObservation(sessionId, "assistant_message", { messageId: data.assistantMessageID }, sanitized, `${data.assistantMessageID}:${data.ordinal}`);
+          }
+          return;
+        }
+        case "session.execution.succeeded":
+        case "session.compaction.ended": {
+          const sessionId = event.data?.sessionID;
+          if (typeof sessionId !== "string") {
+            return;
+          }
+          if (!await checkWorker()) {
+            return;
+          }
+          if (!initializedSessions.has(sessionId)) {
+            return;
+          }
+          try {
+            await WorkerClient.summarize(sessionId, sessionUserTexts.get(sessionId) || "", sessionAssistantTexts.get(sessionId) || "", { observedModel: sessionModels.get(sessionId) });
+          } catch {}
+          return;
+        }
+        case "session.deleted": {
+          const sessionId = event.data?.sessionID;
+          if (typeof sessionId !== "string") {
+            return;
+          }
+          initializedSessions.delete(sessionId);
+          sessionInits.delete(sessionId);
+          contextCache.delete(sessionId);
+          sessionDirs.delete(sessionId);
+          sessionUserTexts.delete(sessionId);
+          sessionAssistantTexts.delete(sessionId);
+          sessionModels.delete(sessionId);
+          return;
+        }
+        default: {
+          return;
+        }
+      }
+    }
+    subscribeAndHandleEvents();
+    return () => {
+      aborted = true;
+      controller.abort();
+      clearTimeout(retryTimer);
+      initializedSessions.clear();
+      sessionInits.clear();
+      contextCache.clear();
+      sessionDirs.clear();
+      sessionUserTexts.clear();
+      sessionAssistantTexts.clear();
+      sessionModels.clear();
+    };
+  }
+});
+export {
+  v2_default as default
+};