@mrc2204/agent-smart-memo 5.0.2 → 5.1.2

package/bin/asm.mjs

@@ -0,0 +1,365 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { runInitOpenClaw } from "../scripts/init-openclaw.mjs";
+import { createShellRunner, runInitSetupFlow, runInstallPlatformFlow } from "../src/cli/platform-installers.ts";
+import { runOpencodeMcpServer } from "./opencode-mcp-server.mjs";
+
+const ASM_PLUGIN_PACKAGE = "@mrc2204/agent-smart-memo";
+const ASM_PLUGIN_ID = "agent-smart-memo";
+
+function text(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function includesAsmPlugin(output) {
+  const haystack = String(output || "").toLowerCase();
+  return (
+    haystack.includes(ASM_PLUGIN_ID) ||
+    haystack.includes(ASM_PLUGIN_PACKAGE.toLowerCase())
+  );
+}
+
+export function parseAsmCliArgs(argv = []) {
+  const args = Array.isArray(argv) ? argv.map((x) => String(x)) : [];
+  const first = args[0] || "";
+
+  if (!first || first === "help" || first === "--help" || first === "-h") {
+    return { command: "help", argv: [] };
+  }
+
+  if (first === "setup-openclaw") {
+    return { command: "setup-openclaw", argv: args.slice(1) };
+  }
+
+  if (first === "setup" && (args[1] || "") === "openclaw") {
+    return { command: "setup-openclaw", argv: args.slice(2) };
+  }
+
+  if (first === "install" && (args[1] || "")) {
+    return {
+      command: "install-platform",
+      platform: String(args[1] || "").trim().toLowerCase(),
+      argv: args.slice(2),
+    };
+  }
+
+  if (first === "init-setup") {
+    return { command: "init-setup", argv: args.slice(1) };
+  }
+
+  if (first === "init" && (args[1] || "") === "setup") {
+    return { command: "init-setup", argv: args.slice(2) };
+  }
+
+  if (first === "init-openclaw") {
+    return { command: "init-openclaw", argv: args.slice(1) };
+  }
+
+  if (first === "init" && (args[1] || "") === "openclaw") {
+    return { command: "init-openclaw", argv: args.slice(2) };
+  }
+
+  if (first === "project-event") {
+    return { command: "project-event", argv: args.slice(1) };
+  }
+
+  if (first === "mcp" && (args[1] || "") === "opencode") {
+    return { command: "mcp-opencode", argv: args.slice(2) };
+  }
+
+  return { command: "unknown", argv: args };
+}
+
+export function printHelp(log = console.log) {
+  log("asm - Agent Smart Memo CLI");
+  log("");
+  log("Usage:");
+  log("  asm setup-openclaw [--yes]");
+  log("  asm setup openclaw [--yes]");
+  log("  asm install openclaw [--yes]");
+  log("  asm install paperclip");
+  log("  asm install opencode");
+  log("  asm init-setup [--yes]");
+  log("  asm init setup [--yes]");
+  log("  asm init-openclaw [--non-interactive]");
+  log("  asm init openclaw [--non-interactive]");
+  log("  asm project-event --project-id <id> --repo-root <path> [--event-type post_commit|post_merge|post_rewrite|manual] [--source-rev <sha>] [--changed-files a,b] [--deleted-files x,y] [--trusted-sync 0|1] [--full-snapshot 0|1]");
+  log("  asm help");
+  log("");
+  log("Roadmap commands (not implemented yet):");
+  log("  asm doctor");
+  log("  asm test-openclaw");
+}
+
+export function detectPluginInstalled(runner = createShellRunner()) {
+  const tryJson = runner("openclaw", ["plugins", "list", "--json"]);
+  if (tryJson.ok) {
+    try {
+      const parsed = JSON.parse(tryJson.stdout || "{}");
+      const pool = [
+        ...(Array.isArray(parsed) ? parsed : []),
+        ...(Array.isArray(parsed?.plugins) ? parsed.plugins : []),
+      ];
+
+      for (const item of pool) {
+        const name = text(item?.name || item?.id || item?.package || item?.pluginId);
+        if (!name) continue;
+        if (includesAsmPlugin(name)) {
+          return { installed: true, source: "list-json" };
+        }
+      }
+    } catch {
+      if (includesAsmPlugin(tryJson.stdout)) {
+        return { installed: true, source: "list-json-text" };
+      }
+    }
+  }
+
+  const tryText = runner("openclaw", ["plugins", "list"]);
+  if (tryText.ok && includesAsmPlugin(tryText.stdout)) {
+    return { installed: true, source: "list-text" };
+  }
+
+  return { installed: false, source: "missing" };
+}
+
+function parseNonInteractiveFlags(argv = []) {
+  const args = Array.isArray(argv) ? argv.map((x) => String(x).trim()).filter(Boolean) : [];
+  const hasYes = args.includes("--yes") || args.includes("-y");
+  const hasNonInteractive = args.includes("--non-interactive");
+
+  return {
+    nonInteractive: hasYes || hasNonInteractive,
+    autoApply: hasYes || hasNonInteractive,
+  };
+}
+
+function parseProjectEventArgs(argv = []) {
+  const args = Array.isArray(argv) ? argv.map((x) => String(x)) : [];
+  const out = {
+    projectId: "",
+    repoRoot: "",
+    sourceRev: "",
+    eventType: "manual",
+    changedFiles: [],
+    deletedFiles: [],
+    trustedSync: false,
+    fullSnapshot: false,
+  };
+  for (let i = 0; i < args.length; i++) {
+    const cur = args[i];
+    const next = args[i + 1] || "";
+    if (cur === "--project-id") { out.projectId = next; i++; continue; }
+    if (cur === "--repo-root") { out.repoRoot = next; i++; continue; }
+    if (cur === "--source-rev") { out.sourceRev = next; i++; continue; }
+    if (cur === "--event-type") { out.eventType = next || "manual"; i++; continue; }
+    if (cur === "--changed-files") { out.changedFiles = next ? next.split(",").map((s) => s.trim()).filter(Boolean) : []; i++; continue; }
+    if (cur === "--deleted-files") { out.deletedFiles = next ? next.split(",").map((s) => s.trim()).filter(Boolean) : []; i++; continue; }
+    if (cur === "--trusted-sync") { out.trustedSync = next === "1" || next === "true"; i++; continue; }
+    if (cur === "--full-snapshot") { out.fullSnapshot = next === "1" || next === "true"; i++; continue; }
+  }
+  return out;
+}
+
+export async function runSetupOpenClawFlow({
+  runner = createShellRunner(),
+  initOpenClaw = runInitOpenClaw,
+  log = console.log,
+  argv = [],
+} = {}) {
+  log("[ASM-84] setup-openclaw: checking OpenClaw CLI ...");
+  const openclawVersion = runner("openclaw", ["--version"]);
+  if (!openclawVersion.ok) {
+    log("[ASM-84] ❌ openclaw binary not found or not executable.");
+    if (openclawVersion.stderr) log(`[ASM-84] details: ${openclawVersion.stderr}`);
+    if (openclawVersion.error) log(`[ASM-84] error: ${openclawVersion.error}`);
+    log("[ASM-84] Please install OpenClaw first, then re-run: asm setup-openclaw");
+    return { ok: false, step: "check-openclaw" };
+  }
+
+  const pluginState = detectPluginInstalled(runner);
+  const setupSummary = pluginState.installed
+    ? {
+        alreadyConfigured: [`plugin installed: ${ASM_PLUGIN_PACKAGE}`],
+        willAdd: [],
+        willUpdate: ["openclaw.json bootstrap via init-openclaw wizard"],
+      }
+    : {
+        alreadyConfigured: [],
+        willAdd: [`plugin install: ${ASM_PLUGIN_PACKAGE}`],
+        willUpdate: ["openclaw.json bootstrap via init-openclaw wizard"],
+      };
+
+  log("[ASM-84] Setup summary (before execution):");
+  log(`- already configured (${setupSummary.alreadyConfigured.length})`);
+  if (!setupSummary.alreadyConfigured.length) log("  • (none)");
+  for (const item of setupSummary.alreadyConfigured) log(`  • ${item}`);
+  log(`- will add (${setupSummary.willAdd.length})`);
+  if (!setupSummary.willAdd.length) log("  • (none)");
+  for (const item of setupSummary.willAdd) log(`  • ${item}`);
+  log(`- will update (${setupSummary.willUpdate.length})`);
+  if (!setupSummary.willUpdate.length) log("  • (none)");
+  for (const item of setupSummary.willUpdate) log(`  • ${item}`);
+
+  if (pluginState.installed) {
+    log(`[ASM-84] plugin already installed (${pluginState.source}).`);
+  } else {
+    log(`[ASM-84] plugin not detected. Installing: ${ASM_PLUGIN_PACKAGE}`);
+    const install = runner("openclaw", ["plugins", "install", ASM_PLUGIN_PACKAGE]);
+    if (!install.ok) {
+      log("[ASM-84] ❌ failed to install plugin via OpenClaw CLI.");
+      if (install.stdout) log(install.stdout);
+      if (install.stderr) log(install.stderr);
+      return { ok: false, step: "install-plugin" };
+    }
+    log("[ASM-84] plugin install command completed.");
+  }
+
+  const mode = parseNonInteractiveFlags(argv);
+  if (mode.nonInteractive) {
+    log("[ASM-84] non-interactive mode enabled; applying defaults/merged config without prompt.");
+  }
+
+  log("[ASM-84] launching init-openclaw bootstrap flow ...");
+  const result = await initOpenClaw({ interactive: !mode.nonInteractive, autoApply: mode.autoApply });
+
+  if (!result?.applied) {
+    log("[ASM-84] setup-openclaw ended without changes (aborted or no write).");
+    return { ok: true, step: "init-openclaw", applied: false };
+  }
+
+  log("[ASM-84] ✅ setup-openclaw completed.");
+  log("[ASM-84] Next steps:");
+  log("  1) Restart OpenClaw runtime");
+  log("  2) Verify plugin loaded and memory tools available");
+  log("  3) Run a quick smoke: memory_slot_set + memory_slot_get");
+
+  return { ok: true, step: "done", applied: true };
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const parsed = parseAsmCliArgs(argv);
+  if (parsed.command === "help") {
+    printHelp();
+    return 0;
+  }
+
+  if (parsed.command === "setup-openclaw") {
+    const result = await runSetupOpenClawFlow({ argv: parsed.argv });
+    return result.ok ? 0 : 1;
+  }
+
+  if (parsed.command === "install-platform") {
+    const result = await runInstallPlatformFlow({
+      platform: parsed.platform,
+      runner: createShellRunner(),
+      initOpenClaw: runInitOpenClaw,
+      log: console.log,
+      argv: parsed.argv,
+      env: process.env,
+      homeDir: process.env.HOME,
+    });
+    return result.ok ? 0 : 1;
+  }
+
+  if (parsed.command === "init-setup") {
+    const result = await runInitSetupFlow({ log: console.log, env: process.env, homeDir: process.env.HOME, argv: parsed.argv });
+    return result.ok ? 0 : 1;
+  }
+
+  if (parsed.command === "init-openclaw") {
+    const mode = parseNonInteractiveFlags(parsed.argv);
+    try {
+      const result = await runInitOpenClaw({ interactive: !mode.nonInteractive, autoApply: mode.autoApply });
+      return result?.applied || mode.autoApply ? 0 : 0;
+    } catch (error) {
+      console.error(`[ASM-84] init-openclaw failed: ${error instanceof Error ? error.message : String(error)}`);
+      return 1;
+    }
+  }
+
+  if (parsed.command === "mcp-opencode") {
+    await runOpencodeMcpServer();
+    return 0;
+  }
+
+  if (parsed.command === "project-event") {
+    const event = parseProjectEventArgs(parsed.argv);
+    if (!event.projectId || !event.repoRoot) {
+      console.error('[ASM-87] project-event requires --project-id and --repo-root');
+      return 1;
+    }
+    const pluginId = 'agent-smart-memo';
+    const cfgPath = resolve(process.env.HOME || '', '.openclaw', 'openclaw.json');
+    let qdrantCollection = 'mrc_bot';
+    let llmBaseUrl = 'http://localhost:8317/v1';
+    let llmApiKey = 'proxypal-local';
+    let llmModel = 'gpt-5.4';
+    let embedModel = 'qwen3-embedding:0.6b';
+    let embedDimensions = 1024;
+    let slotDbDir = resolve(process.env.HOME || '', '.openclaw', 'agent-memo');
+    try {
+      const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
+      const cfg = raw?.plugins?.entries?.[pluginId]?.config || {};
+      qdrantCollection = cfg.qdrantCollection || qdrantCollection;
+      llmBaseUrl = cfg.llmBaseUrl || llmBaseUrl;
+      llmApiKey = cfg.llmApiKey || llmApiKey;
+      llmModel = cfg.llmModel || llmModel;
+      embedModel = cfg.embedModel || embedModel;
+      embedDimensions = cfg.embedDimensions || embedDimensions;
+      slotDbDir = cfg.slotDbDir || slotDbDir;
+    } catch {}
+
+    process.env.OPENCLAW_SLOTDB_DIR = slotDbDir;
+    process.env.AGENT_MEMO_PROJECT_WORKSPACE_ROOT = event.repoRoot;
+    process.env.AGENT_MEMO_REPO_CLONE_ROOT = event.repoRoot;
+    process.env.PROJECT_WORKSPACE_ROOT = event.repoRoot;
+    process.env.REPO_CLONE_ROOT = event.repoRoot;
+    process.env.QDRANT_COLLECTION = qdrantCollection;
+    process.env.LLM_BASE_URL = llmBaseUrl;
+    process.env.LLM_API_KEY = llmApiKey;
+    process.env.LLM_MODEL = llmModel;
+    process.env.EMBED_MODEL = embedModel;
+    process.env.EMBEDDING_MODEL = embedModel;
+    process.env.EMBEDDING_DIMENSIONS = String(embedDimensions);
+
+    const { SlotDB } = await import('../dist/db/slot-db.js');
+    const { DefaultMemoryUseCasePort } = await import('../dist/core/usecases/default-memory-usecase-port.js');
+    const db = new SlotDB(slotDbDir);
+    const usecase = new DefaultMemoryUseCasePort(db);
+    try {
+      const result = await usecase.run('project.index_event', {
+        context: { userId: 'telegram:dm:5165741309', agentId: 'assistant', metadata: { projectWorkspaceRoot: event.repoRoot } },
+        meta: { source: 'cli', toolName: 'asm.project-event', projectWorkspaceRoot: event.repoRoot },
+        payload: {
+          project_id: event.projectId,
+          repo_root: event.repoRoot,
+          source_rev: event.sourceRev || null,
+          event_type: event.eventType,
+          changed_files: event.changedFiles,
+          deleted_files: event.deletedFiles,
+          trusted_sync: event.trustedSync,
+          full_snapshot: event.fullSnapshot,
+        },
+      });
+      console.log(JSON.stringify(result, null, 2));
+      db.close();
+      return 0;
+    } catch (error) {
+      db.close();
+      console.error(`[ASM-87] project-event failed: ${error instanceof Error ? error.message : String(error)}`);
+      return 1;
+    }
+  }
+
+  console.error(`[ASM-84] Unknown command: ${argv.join(" ") || "(empty)"}`);
+  printHelp(console.error);
+  return 1;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().then((code) => {
+    process.exitCode = code;
+  });
+}

package/bin/opencode-mcp-server.mjs

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+import process from "node:process";
+
+const PROTOCOL_VERSION = "2024-11-05";
+
+function makeTool(name, description, inputSchema) {
+  return { name, description, inputSchema };
+}
+
+export function buildOpencodeMcpToolDescriptors() {
+  return [
+    makeTool(
+      "asm_project_binding_preview",
+      "Resolve ASM active project binding in read-only mode using project_id/project_alias/repo_root/session_project_alias selectors.",
+      {
+        type: "object",
+        properties: {
+          project_id: { type: "string" },
+          project_alias: { type: "string" },
+          repo_root: { type: "string" },
+          session_project_alias: { type: "string" },
+          allow_cross_project: { type: "boolean" },
+        },
+      },
+    ),
+    makeTool(
+      "asm_project_opencode_search",
+      "Run ASM read-only project-scoped retrieval for OpenCode after resolving project binding.",
+      {
+        type: "object",
+        properties: {
+          query: { type: "string" },
+          limit: { type: "number" },
+          project_id: { type: "string" },
+          project_alias: { type: "string" },
+          repo_root: { type: "string" },
+          session_project_alias: { type: "string" },
+          explicit_project_id: { type: "string" },
+          explicit_project_alias: { type: "string" },
+          explicit_cross_project: { type: "boolean" },
+        },
+        required: ["query"],
+      },
+    ),
+    makeTool(
+      "asm_project_coding_packet",
+      "Build coding packet (foundation lane) for OpenCode using ASM project-aware/code-aware retrieval context.",
+      {
+        type: "object",
+        properties: {
+          project_id: { type: "string" },
+          project_alias: { type: "string" },
+          query: { type: "string" },
+          objective: { type: "string" },
+          task_id: { type: "string" },
+          tracker_issue_key: { type: "string" },
+          task_title: { type: "string" },
+          symbol_name: { type: "string" },
+          relative_path: { type: "string" },
+          route_path: { type: "string" },
+          limit: { type: "number" },
+          acceptance_criteria: { type: "array", items: { type: "string" } },
+          constraints: { type: "array", items: { type: "string" } },
+          out_of_scope: { type: "array", items: { type: "string" } },
+          validation_commands: { type: "array", items: { type: "string" } },
+        },
+      },
+    ),
+  ];
+}
+
+let usecasePortPromise = null;
+async function getUseCasePort() {
+  if (!usecasePortPromise) {
+    usecasePortPromise = (async () => {
+      const { resolveAsmCoreSlotDbDir } = await import(new URL("../dist/shared/asm-config.js", import.meta.url));
+      const { SlotDB } = await import(new URL("../dist/db/slot-db.js", import.meta.url));
+      const { DefaultMemoryUseCasePort } = await import(new URL("../dist/core/usecases/default-memory-usecase-port.js", import.meta.url));
+      const slotDbDir =
+        resolveAsmCoreSlotDbDir({ env: process.env, homeDir: process.env.HOME }) ||
+        process.env.OPENCLAW_SLOTDB_DIR ||
+        `${process.env.HOME}/.openclaw/agent-memo`;
+      const db = new SlotDB(slotDbDir);
+      return { db, usecase: new DefaultMemoryUseCasePort(db) };
+    })();
+  }
+  return usecasePortPromise;
+}
+
+function response(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+
+function errorResponse(id, code, message) {
+  return { jsonrpc: "2.0", id, error: { code, message } };
+}
+
+let outputTransportMode = "content-length";
+
+function setOutputTransportMode(mode) {
+  if (mode === "json-line" || mode === "content-length") {
+    outputTransportMode = mode;
+  }
+}
+
+function writeMessage(message) {
+  const encoded = JSON.stringify(message);
+  if (outputTransportMode === "json-line") {
+    process.stdout.write(`${encoded}\n`);
+    return;
+  }
+
+  const body = Buffer.from(encoded, "utf8");
+  const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "utf8");
+  process.stdout.write(Buffer.concat([header, body]));
+}
+
+async function handleToolCall(name, args) {
+  const { usecase } = await getUseCasePort();
+  const context = {
+    userId: process.env.ASM_MCP_USER_ID || "default",
+    agentId: process.env.ASM_MCP_AGENT_ID || "opencode",
+  };
+
+  if (name === "asm_project_binding_preview") {
+    const data = await usecase.run("project.binding_preview", {
+      context,
+      meta: { source: "cli", toolName: "asm.mcp.opencode.binding_preview" },
+      payload: args || {},
+    });
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  }
+
+  if (name === "asm_project_opencode_search") {
+    const data = await usecase.run("project.opencode_search", {
+      context,
+      meta: { source: "cli", toolName: "asm.mcp.opencode.search" },
+      payload: args || {},
+    });
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  }
+
+  if (name === "asm_project_coding_packet") {
+    const data = await usecase.run("project.coding_packet", {
+      context,
+      meta: { source: "cli", toolName: "asm.mcp.opencode.coding_packet" },
+      payload: args || {},
+    });
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  }
+
+  return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+}
+
+async function processRpcMessage(message) {
+  const { id, method, params } = message || {};
+  const hasId = id !== undefined && id !== null;
+
+  if (method === "initialize") {
+    if (!hasId) return;
+    writeMessage(response(id, {
+      protocolVersion: PROTOCOL_VERSION,
+      serverInfo: { name: "asm-opencode-mcp", version: "1.0.0" },
+      capabilities: { tools: { listChanged: false } },
+    }));
+    return;
+  }
+
+  if (method === "notifications/initialized") {
+    return;
+  }
+
+  if (method === "tools/list") {
+    if (!hasId) return;
+    writeMessage(response(id, { tools: buildOpencodeMcpToolDescriptors() }));
+    return;
+  }
+
+  if (method === "tools/call") {
+    if (!hasId) return;
+    try {
+      const result = await handleToolCall(params?.name, params?.arguments || {});
+      writeMessage(response(id, result));
+    } catch (error) {
+      writeMessage(response(id, {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      }));
+    }
+    return;
+  }
+
+  if (!hasId) {
+    return;
+  }
+
+  writeMessage(errorResponse(id, -32601, `Method not found: ${method}`));
+}
+
+function findHeaderBoundary(buffer) {
+  const crlf = buffer.indexOf("\r\n\r\n");
+  if (crlf !== -1) {
+    return { headerEnd: crlf, separatorLength: 4 };
+  }
+
+  const lf = buffer.indexOf("\n\n");
+  if (lf !== -1) {
+    return { headerEnd: lf, separatorLength: 2 };
+  }
+
+  return null;
+}
+
+function takeJsonLineMessage(buffer) {
+  if (!buffer.length) return null;
+  const first = String.fromCharCode(buffer[0]);
+  if (first !== "{" && first !== "[") return null;
+
+  const newlineIndex = buffer.indexOf("\n");
+  if (newlineIndex === -1) return null;
+
+  const line = buffer.slice(0, newlineIndex).toString("utf8").trim();
+  if (!line) {
+    return { consumed: newlineIndex + 1, message: null };
+  }
+
+  return { consumed: newlineIndex + 1, message: line };
+}
+
+export async function runOpencodeMcpServer() {
+  let buffer = Buffer.alloc(0);
+  let requestChain = Promise.resolve();
+
+  const enqueue = (message) => {
+    requestChain = requestChain
+      .then(() => processRpcMessage(message))
+      .catch((error) => {
+        writeMessage(errorResponse(null, -32603, error instanceof Error ? error.message : String(error)));
+      });
+  };
+
+  const onData = (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+
+    while (true) {
+      const boundary = findHeaderBoundary(buffer);
+      if (boundary) {
+        const { headerEnd, separatorLength } = boundary;
+        const headerText = buffer.slice(0, headerEnd).toString("utf8");
+        const match = headerText.match(/Content-Length:\s*(\d+)/i);
+        if (!match) {
+          buffer = buffer.slice(headerEnd + separatorLength);
+          continue;
+        }
+
+        const contentLength = Number(match[1]);
+        const totalLength = headerEnd + separatorLength + contentLength;
+        if (!Number.isFinite(contentLength) || contentLength < 0) {
+          buffer = buffer.slice(headerEnd + separatorLength);
+          continue;
+        }
+        if (buffer.length < totalLength) break;
+
+        const body = buffer.slice(headerEnd + separatorLength, totalLength).toString("utf8");
+        buffer = buffer.slice(totalLength);
+        setOutputTransportMode("content-length");
+
+        try {
+          const message = JSON.parse(body);
+          enqueue(message);
+        } catch (error) {
+          writeMessage(errorResponse(null, -32700, error instanceof Error ? error.message : String(error)));
+        }
+        continue;
+      }
+
+      const jsonLine = takeJsonLineMessage(buffer);
+      if (!jsonLine) {
+        break;
+      }
+
+      buffer = buffer.slice(jsonLine.consumed);
+      if (!jsonLine.message) {
+        continue;
+      }
+      setOutputTransportMode("json-line");
+
+      try {
+        const message = JSON.parse(jsonLine.message);
+        enqueue(message);
+      } catch (error) {
+        writeMessage(errorResponse(null, -32700, error instanceof Error ? error.message : String(error)));
+      }
+    }
+  };
+
+  if (typeof process.stdin.resume === "function") {
+    process.stdin.resume();
+  }
+
+  process.stdin.on("data", onData);
+
+  await new Promise((resolve) => {
+    let closed = false;
+    const finish = () => {
+      if (closed) return;
+      closed = true;
+      resolve(undefined);
+    };
+
+    process.stdin.on("end", finish);
+    process.stdin.on("close", finish);
+    process.on("SIGINT", finish);
+    process.on("SIGTERM", finish);
+  });
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runOpencodeMcpServer();
+}

package/dist/core/contracts/adapter-contracts.d.ts

@@ -17,7 +17,7 @@ export interface CoreRequestEnvelope<TPayload> {
         requestId?: string;
     };
 }
-export type MemoryUseCaseName = "slot.get" | "slot.set" | "slot.list" | "slot.delete" | "project.register" | "project.get" | "project.list" | "project.set_registration_state" | "project.set_tracker_mapping" | "project.register_command" | "project.link_tracker" | "project.trigger_index" | "project.reindex_diff" | "project.index_watch_get" | "project.task_registry_upsert" | "project.task_lineage_context" | "project.hybrid_search" | "project.legacy_backfill" | "project.telegram_onboarding" | "memory.capture" | "memory.search" | "graph.entity.get" | "graph.entity.set" | "graph.rel.add" | "graph.rel.remove" | "graph.search";
+export type MemoryUseCaseName = "slot.get" | "slot.set" | "slot.list" | "slot.delete" | "project.register" | "project.get" | "project.list" | "project.set_registration_state" | "project.set_tracker_mapping" | "project.register_command" | "project.link_tracker" | "project.trigger_index" | "project.deindex" | "project.detach" | "project.unregister" | "project.purge_preview" | "project.purge" | "project.reindex_diff" | "project.index_event" | "project.install_hooks" | "project.index_watch_get" | "project.task_registry_upsert" | "project.task_lineage_context" | "project.hybrid_search" | "project.change_overlay.query" | "project.legacy_backfill" | "project.telegram_onboarding" | "project.feature_pack.generate" | "project.feature_pack.query" | "project.developer_query" | "project.binding_preview" | "project.opencode_search" | "memory.capture" | "memory.search" | "graph.entity.get" | "graph.entity.set" | "graph.rel.add" | "graph.rel.remove" | "graph.search" | "graph.code.upsert" | "graph.code.chain";
 export interface MemoryUseCasePort {
     run<TReq, TRes>(useCase: MemoryUseCaseName, req: CoreRequestEnvelope<TReq>): Promise<TRes>;
 }