@devtheops/opencode-plugin-mempalace 0.1.0 → 1.1.0

package/README.md

@@ -16,10 +16,12 @@ An [OpenCode](https://opencode.ai) server plugin that integrates [MemPalace](htt
 
 The plugin:
 
-- installs the `mempalace` Python package if it is missing
+- requires an existing `mempalace` installation and logs startup diagnostics if it is missing
 - registers a local `mempalace` MCP server
 - injects MemPalace slash commands into OpenCode
 - injects a bundled `mempalace` skill into OpenCode
+- automatically mines OpenCode session transcripts into MemPalace conversation memory
+- can inject `mempalace wake-up` memory into the system prompt and compaction context
 
 ## Installation
 
@@ -32,6 +34,47 @@ Add the plugin to your OpenCode config:
 }
 ```
 
+You can configure automatic conversation mining with a per-session message threshold:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [["@devtheops/opencode-plugin-mempalace", { "threshold": 30 }]]
+}
+```
+
+Full plugin options:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [["@devtheops/opencode-plugin-mempalace", {
+    "threshold": 15,
+    "autoMine": true,
+    "injectWakeUp": true,
+    "injectOnCompaction": true,
+    "maxWakeUpChars": 4000,
+    "flushOnIdle": true,
+    "flushOnExit": true
+  }]]
+}
+```
+
+`threshold` rules:
+
+- default: `15`
+- `0`: disable threshold-triggered mining and only flush on idle, delete, and compaction
+- invalid or negative values fall back to `15`
+
+Other options:
+
+- `autoMine`: enable or disable automatic conversation mining entirely
+- `injectWakeUp`: inject `mempalace wake-up` output into the system prompt
+- `injectOnCompaction`: inject `mempalace wake-up` output into compaction context
+- `maxWakeUpChars`: truncate injected wake-up memory to this many characters
+- `flushOnIdle`: flush dirty sessions when OpenCode marks them idle or deleted
+- `flushOnExit`: register graceful process-exit hooks
+
 For local development you can point OpenCode directly at this checkout:
 
 ```json
@@ -45,7 +88,7 @@ For local development you can point OpenCode directly at this checkout:
 
 - OpenCode
 - Python 3.9+
-- `pip`
+- MemPalace installed already, either as `mempalace` on `PATH` or as a Python module importable by `python3` or `python`
 
 ## What It Adds
 
@@ -66,14 +109,17 @@ If a `mempalace` MCP server is already configured, the plugin leaves it alone.
 
 ## Runtime Behavior
 
-When OpenCode loads the plugin, it checks for `python3` or `python` and then verifies whether the `mempalace` package is importable.
-If not, it runs:
+When OpenCode loads the plugin, it checks for the `mempalace` CLI first, then falls back to verifying whether the `mempalace` package is importable through `python3` or `python`.
+
+If MemPalace is missing, the plugin does not install it automatically. Instead it logs explicit warnings so MCP startup failures are easier to diagnose.
+
+The plugin also exports OpenCode session transcripts through the OpenCode client API and mines them with:
 
 ```bash
-python3 -m pip install --upgrade mempalace
+mempalace mine <transcript-file> --mode convos
 ```
 
-If installation fails, the plugin logs a warning and OpenCode continues running.
+Threshold-based mining is configurable through the plugin `threshold` option.
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devtheops/opencode-plugin-mempalace",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "MemPalace plugin for OpenCode. Installs the Python package, registers the MCP server, and injects commands and a bundled skill.",
   "type": "module",
   "author": "DEVtheOPS",
@@ -46,5 +46,8 @@
   "scripts": {
     "test": "bun test",
     "typecheck": "tsc --noEmit"
-  }
+  },
+  "oc-plugin": [
+    "server"
+  ]
 }

package/skills/mempalace/SKILL.md

@@ -11,15 +11,13 @@ MemPalace is a searchable memory system for mined projects and conversations.
 
 ## Prerequisites
 
-This plugin tries to install `mempalace` automatically through `pip` when OpenCode loads the plugin.
-
 Verify the CLI is available:
 
 ```bash
 mempalace --version
 ```
 
-If it is still missing, install it manually:
+If it is missing, install it manually:
 
 ```bash
 python3 -m pip install --upgrade mempalace
@@ -52,4 +50,4 @@ After retrieving the instructions, follow them step by step.
 ## MCP Server
 
 This plugin injects a local `mempalace` MCP server into OpenCode config at runtime.
-If the tools are missing, confirm the Python package installed successfully.
+If the tools are missing, confirm the `mempalace` CLI or Python package is installed and check the plugin logs for startup diagnostics.

package/src/config.ts

@@ -42,6 +42,13 @@ function injectCommands(cfg: ConfigWithExtensions) {
     "If command arguments are present, treat them as the search query.",
   );
   commands["mempalace-status"] = template("status", "Show MemPalace status, room counts, and health.");
+  commands["mempalace-mine-session"] = {
+    description: "Export the current OpenCode session and mine it into MemPalace conversation memory.",
+    template: [
+      "Use the `mempalace_mine_session` tool to export the current OpenCode session and mine it into MemPalace.",
+      "If the tool reports that MemPalace is unavailable or the project is not initialized, run `/mempalace-init` first.",
+    ].join("\n\n"),
+  };
 }
 
 function injectMcp(cfg: ConfigWithExtensions) {
@@ -51,11 +58,7 @@ function injectMcp(cfg: ConfigWithExtensions) {
 
   mcp["mempalace"] = {
     type: "local",
-    command: [
-      "sh",
-      "-lc",
-      "if command -v python3 >/dev/null 2>&1; then exec python3 -m mempalace.mcp_server; else exec python -m mempalace.mcp_server; fi",
-    ],
+    command: ["python3", "-m", "mempalace.mcp_server"],
     enabled: true,
     timeout: 10000,
   };

package/src/index.ts

@@ -1,11 +1,12 @@
 import { fileURLToPath } from "node:url";
-import type { Plugin } from "@opencode-ai/plugin";
+import { tool, type Plugin } from "@opencode-ai/plugin";
 import type { ConfigWithExtensions } from "./config.ts";
 import { applyMemPalaceConfig } from "./config.ts";
+import { diagnoseMemPalace, isProjectReady, resolveMemPalaceCommand, wakeUp } from "./mempalace.ts";
+import { createSessionMiner, resolveThreshold } from "./mining.ts";
 
-const PACKAGE_NAME = "mempalace";
 const SKILLS_DIR = fileURLToPath(new URL("../skills", import.meta.url));
-const IMPORT_CHECK = "import importlib.util, sys; sys.exit(0 if importlib.util.find_spec('mempalace') else 1)";
+const DEFAULT_MAX_WAKE_UP_CHARS = 4000;
 
 type Logger = {
   app?: {
@@ -37,60 +38,130 @@ async function log(
   });
 }
 
-async function run(cmd: string[]) {
-  const proc = Bun.spawn({
-    cmd,
-    stdout: "pipe",
-    stderr: "pipe",
+function resolveBoolean(value: unknown, fallback: boolean) {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function resolveMaxWakeUpChars(value: unknown) {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) return DEFAULT_MAX_WAKE_UP_CHARS;
+  return parsed;
+}
+
+export const server: Plugin = async (input, options) => {
+  await diagnoseMemPalace(input.client as Logger);
+
+  const threshold = resolveThreshold(options?.threshold);
+  const autoMine = resolveBoolean(options?.autoMine, true);
+  const injectWakeUp = resolveBoolean(options?.injectWakeUp, true);
+  const injectOnCompaction = resolveBoolean(options?.injectOnCompaction, true);
+  const flushOnIdle = resolveBoolean(options?.flushOnIdle, true);
+  const flushOnExit = resolveBoolean(options?.flushOnExit, true);
+  const maxWakeUpChars = resolveMaxWakeUpChars(options?.maxWakeUpChars);
+
+  await log(input.client as Logger, "info", "MemPalace plugin options configured.", {
+    threshold: String(threshold),
+    autoMine: String(autoMine),
+    injectWakeUp: String(injectWakeUp),
+    injectOnCompaction: String(injectOnCompaction),
+    flushOnIdle: String(flushOnIdle),
+    flushOnExit: String(flushOnExit),
+    maxWakeUpChars: String(maxWakeUpChars),
   });
 
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ]);
+  const miner = createSessionMiner(input, threshold);
+  let commandPromise: Promise<string[] | null> | undefined;
+  let projectReady: boolean | undefined;
+  let readinessLogged = false;
 
-  return { stdout, stderr, exitCode };
-}
+  async function ensureReady() {
+    commandPromise ??= resolveMemPalaceCommand();
+    const command = await commandPromise;
+    if (!command) return { command: null, ready: false };
 
-async function ensureMemPalaceInstalled(client: Logger) {
-  const python = Bun.which("python3") ?? Bun.which("python");
-  if (!python) {
-    await log(
-      client,
-      "warn",
-      "Could not find python3 or python. MemPalace MCP setup will remain unavailable until Python is installed.",
-    );
-    return;
-  }
+    if (projectReady === undefined) {
+      projectReady = await isProjectReady(command);
+    }
+
+    if (!projectReady && !readinessLogged) {
+      readinessLogged = true;
+      await log(input.client as Logger, "warn", "MemPalace is installed but this project does not appear to be initialized. Wake-up injection and automatic mining are disabled until you run /mempalace-init.", {
+        directory: input.directory,
+      });
+    }
 
-  const check = await run([python, "-c", IMPORT_CHECK]);
-  if (check.exitCode === 0) {
-    await log(client, "debug", "MemPalace Python package already installed.", { python });
-    return;
+    return { command, ready: Boolean(projectReady) };
   }
 
-  await log(client, "info", "Installing MemPalace Python package.", { python, package: PACKAGE_NAME });
-  const install = await run([python, "-m", "pip", "install", "--upgrade", PACKAGE_NAME]);
+  async function injectMemory(kind: "system" | "context", output: { system?: string[]; context?: string[] }) {
+    const status = await ensureReady();
+    if (!status.command || !status.ready) return;
 
-  if (install.exitCode === 0) {
-    await log(client, "info", "Installed MemPalace Python package.", { python, package: PACKAGE_NAME });
-    return;
-  }
+    const memory = await wakeUp(status.command, maxWakeUpChars);
+    if (!memory) return;
 
-  await log(client, "warn", "MemPalace Python package install failed.", {
-    python,
-    stderr: install.stderr.trim() || "unknown error",
-  });
-}
+    if (kind === "system") output.system?.push(memory);
+    if (kind === "context") output.context?.push(memory);
+  }
 
-export const server: Plugin = async ({ client }) => {
-  await ensureMemPalaceInstalled(client);
+  if (flushOnExit) {
+    process.on("SIGINT", () => {
+      process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+      process.exit(143);
+    });
+  }
 
   return {
     config: async (cfg) => {
       applyMemPalaceConfig(cfg as ConfigWithExtensions, SKILLS_DIR);
     },
+    tool: {
+      mempalace_mine_session: tool({
+        description: "Export the current OpenCode session transcript and mine it into MemPalace conversation memory.",
+        args: {},
+        execute: async (_args, context) => {
+          await miner.mineNow(context.sessionID, "manual-tool");
+          return "Requested MemPalace mining for the current OpenCode session.";
+        },
+      }),
+    },
+    "chat.message": async ({ sessionID }) => {
+      if (!autoMine) return;
+      await miner.noteMessage(sessionID);
+    },
+    event: async ({ event }) => {
+      if (!flushOnIdle || !autoMine) return;
+
+      const sessionID = "properties" in event
+        ? (event.properties as { sessionID?: string; info?: { id?: string } })?.sessionID ??
+          (event.properties as { info?: { id?: string } })?.info?.id
+        : undefined;
+      if (!sessionID) return;
+
+      if (event.type === "session.idle" || event.type === "session.deleted") {
+        await miner.flush(sessionID, event.type);
+      }
+
+      if (event.type === "session.status") {
+        const status = (event.properties as { status?: { type?: string } })?.status?.type;
+        if (status === "idle") {
+          await miner.flush(sessionID, "session.status.idle");
+        }
+      }
+    },
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (!injectWakeUp) return;
+      await injectMemory("system", output);
+    },
+    "experimental.session.compacting": async ({ sessionID }, output) => {
+      if (autoMine) {
+        await miner.flush(sessionID, "compacting");
+      }
+      if (!injectOnCompaction) return;
+      await injectMemory("context", output);
+    },
   };
 };
 

package/src/mempalace.ts

@@ -0,0 +1,113 @@
+type Logger = {
+  app?: {
+    log?: (input: {
+      body: {
+        service: string;
+        level: "debug" | "info" | "warn" | "error";
+        message: string;
+        extra?: Record<string, string>;
+      };
+    }) => Promise<unknown>;
+  };
+};
+
+const IMPORT_CHECK = "import importlib.util, sys; sys.exit(0 if importlib.util.find_spec('mempalace') else 1)";
+
+async function log(
+  client: Logger,
+  level: "debug" | "info" | "warn" | "error",
+  message: string,
+  extra?: Record<string, string>,
+) {
+  if (!client.app?.log) return;
+  await client.app.log({
+    body: {
+      service: "opencode-plugin-mempalace",
+      level,
+      message,
+      extra,
+    },
+  });
+}
+
+export async function run(cmd: string[]) {
+  const proc = Bun.spawn({
+    cmd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  return { stdout, stderr, exitCode };
+}
+
+export async function diagnoseMemPalace(client: Logger) {
+  const cli = Bun.which("mempalace");
+  const python = Bun.which("python3") ?? Bun.which("python");
+  if (cli) {
+    await log(client, "info", "MemPalace CLI detected.", { cli });
+    return;
+  }
+
+  if (!python) {
+    await log(
+      client,
+      "warn",
+      "MemPalace is required but neither the `mempalace` CLI nor python3/python is available.",
+    );
+    return;
+  }
+
+  const check = await run([python, "-c", IMPORT_CHECK]);
+  if (check.exitCode === 0) {
+    await log(client, "info", "MemPalace Python package detected via Python module lookup.", { python });
+    return;
+  }
+
+  await log(client, "warn", "MemPalace is not installed. The MCP server and conversation mining will fail until it is installed manually.", {
+    python,
+  });
+}
+
+export async function resolveMemPalaceCommand() {
+  if (Bun.which("mempalace")) return ["mempalace"];
+
+  const python = Bun.which("python3") ?? Bun.which("python");
+  if (!python) return null;
+
+  const check = await run([python, "-c", IMPORT_CHECK]);
+  if (check.exitCode !== 0) return null;
+  return [python, "-m", "mempalace"];
+}
+
+export async function isProjectReady(command: string[]) {
+  const result = await run([...command, "status"]);
+  if (result.exitCode === 0) return true;
+
+  const output = `${result.stderr}\n${result.stdout}`.toLowerCase();
+  if (
+    output.includes("mempalace.yaml") ||
+    output.includes("not initialized") ||
+    output.includes("run mempalace init") ||
+    output.includes("no palace")
+  ) {
+    return false;
+  }
+
+  return false;
+}
+
+export async function wakeUp(command: string[], maxChars: number) {
+  const result = await run([...command, "wake-up"]);
+  if (result.exitCode !== 0) return null;
+
+  const text = result.stdout.trim();
+  if (!text) return null;
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\n...[Memory Truncated]`;
+}

package/src/mining.ts

@@ -0,0 +1,158 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { isProjectReady, resolveMemPalaceCommand, run } from "./mempalace.ts";
+import { exportSessionTranscript } from "./session.ts";
+
+type Logger = {
+  app?: {
+    log?: (input: {
+      body: {
+        service: string;
+        level: "debug" | "info" | "warn" | "error";
+        message: string;
+        extra?: Record<string, string>;
+      };
+    }) => Promise<unknown>;
+  };
+};
+
+type SessionState = {
+  dirtyCount: number;
+  mining: boolean;
+};
+
+const DEFAULT_THRESHOLD = 15;
+
+export function resolveThreshold(value: unknown): number {
+  if (value === undefined) return DEFAULT_THRESHOLD;
+
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) return DEFAULT_THRESHOLD;
+  return parsed;
+}
+
+async function log(
+  client: Logger,
+  level: "debug" | "info" | "warn" | "error",
+  message: string,
+  extra?: Record<string, string>,
+) {
+  if (!client.app?.log) return;
+  await client.app.log({
+    body: {
+      service: "opencode-plugin-mempalace",
+      level,
+      message,
+      extra,
+    },
+  });
+}
+
+export function createSessionMiner(input: PluginInput, threshold = DEFAULT_THRESHOLD) {
+  const state = new Map<string, SessionState>();
+  let projectReady: boolean | undefined;
+  let projectReadinessLogged = false;
+
+  function get(sessionID: string): SessionState {
+    const existing = state.get(sessionID);
+    if (existing) return existing;
+    const fresh = { dirtyCount: 0, mining: false };
+    state.set(sessionID, fresh);
+    return fresh;
+  }
+
+  async function mineSession(sessionID: string, reason: string) {
+    const session = get(sessionID);
+    if (session.mining || session.dirtyCount === 0) return;
+
+    session.mining = true;
+    try {
+      const command = await resolveMemPalaceCommand();
+      if (!command) {
+        await log(input.client as unknown as Logger, "warn", "MemPalace conversation mining skipped because the CLI is unavailable.", {
+          sessionID,
+          reason,
+          directory: input.directory,
+        });
+        return;
+      }
+
+      if (projectReady === undefined) {
+        projectReady = await isProjectReady(command);
+      }
+
+      if (!projectReady) {
+        if (!projectReadinessLogged) {
+          projectReadinessLogged = true;
+          await log(input.client as unknown as Logger, "warn", "MemPalace is installed but this project does not appear to be initialized. Skipping automatic conversation mining. Run /mempalace-init first.", {
+            directory: input.directory,
+          });
+        }
+        return;
+      }
+
+      const transcript = await exportSessionTranscript(
+        input.client as unknown as Parameters<typeof exportSessionTranscript>[0],
+        sessionID,
+        input.directory,
+      );
+
+      await log(input.client as unknown as Logger, "info", "Mining OpenCode session transcript into MemPalace.", {
+        sessionID,
+        reason,
+        messages: String(transcript.messageCount),
+        transcript: transcript.path,
+      });
+
+      const result = await run([...command, "mine", transcript.path, "--mode", "convos"]);
+      if (result.exitCode !== 0) {
+        await log(input.client as unknown as Logger, "warn", "MemPalace conversation mining failed.", {
+          sessionID,
+          reason,
+          stderr: result.stderr.trim() || "unknown error",
+        });
+        return;
+      }
+
+      session.dirtyCount = 0;
+      await log(input.client as unknown as Logger, "info", "MemPalace conversation mining completed.", {
+        sessionID,
+        reason,
+        messages: String(transcript.messageCount),
+      });
+    } catch (error) {
+      await log(input.client as unknown as Logger, "warn", "MemPalace conversation mining threw an error.", {
+        sessionID,
+        reason,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    } finally {
+      session.mining = false;
+    }
+  }
+
+  async function noteMessage(sessionID: string) {
+    const session = get(sessionID);
+    session.dirtyCount += 1;
+    if (threshold === 0) return;
+    if (session.dirtyCount < threshold) return;
+    await mineSession(sessionID, "threshold");
+  }
+
+  async function flush(sessionID: string, reason: string) {
+    await mineSession(sessionID, reason);
+  }
+
+  async function mineNow(sessionID: string, reason: string) {
+    const session = get(sessionID);
+    if (session.dirtyCount === 0) {
+      session.dirtyCount = 1;
+    }
+    await mineSession(sessionID, reason);
+  }
+
+  return {
+    noteMessage,
+    flush,
+    mineNow,
+  };
+}

package/src/session.ts

@@ -0,0 +1,77 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Part } from "@opencode-ai/sdk";
+
+type SessionMessageRecord = {
+  info: {
+    id: string;
+    role: "user" | "assistant";
+    time?: {
+      created?: number;
+      completed?: number;
+    };
+  };
+  parts: Part[];
+};
+
+type ClientLike = {
+  session: {
+    messages: (input: {
+      sessionID: string;
+      directory?: string;
+      workspace?: string;
+      limit?: number;
+      before?: string;
+    }) => Promise<SessionMessageRecord[]>;
+  };
+};
+
+function formatPart(part: Part): string | null {
+  if ("text" in part && typeof part.text === "string" && part.text.trim()) {
+    return part.text.trim();
+  }
+
+  if ("tool" in part && typeof part.tool === "string") {
+    return `[tool:${part.tool}]`;
+  }
+
+  if ("title" in part && typeof part.title === "string" && part.title.trim()) {
+    return `[${part.title.trim()}]`;
+  }
+
+  return null;
+}
+
+function formatTimestamp(created?: number, completed?: number): string {
+  const value = created ?? completed;
+  if (!value) return "unknown-time";
+  return new Date(value).toISOString();
+}
+
+export async function exportSessionTranscript(
+  client: ClientLike,
+  sessionID: string,
+  directory: string,
+): Promise<{ path: string; messageCount: number }> {
+  const messages = await client.session.messages({
+    sessionID,
+    directory,
+  });
+
+  const body = messages
+    .map(({ info, parts }) => {
+      const renderedParts = parts.map(formatPart).filter((value): value is string => Boolean(value));
+      return [
+        `## ${info.role.toUpperCase()} ${formatTimestamp(info.time?.created, info.time?.completed)}`,
+        renderedParts.join("\n\n") || "[no text content]",
+      ].join("\n\n");
+    })
+    .join("\n\n---\n\n");
+
+  const tempDir = await mkdtemp(join(tmpdir(), "opencode-mempalace-"));
+  const path = join(tempDir, `${sessionID}.md`);
+  await writeFile(path, body || "[empty session]", "utf8");
+
+  return { path, messageCount: messages.length };
+}