@rvboris/opencode-mempalace 0.2.0 → 0.3.0

package/dist/bridge/mempalace_adapter.py

@@ -8,17 +8,22 @@ from pathlib import Path
 
 from mempalace.config import MempalaceConfig
 from mempalace.convo_miner import mine_convos
-from mempalace.mcp_server import (
-    tool_add_drawer,
-    tool_diary_write,
-    tool_kg_add,
-    tool_search,
-)
+import mempalace.mcp_server as mcp_server
+
+
+restore_stdout = getattr(mcp_server, "_restore_stdout", None)
+if callable(restore_stdout):
+    restore_stdout()
 
 
 def write_result(result: dict) -> None:
     output = json.dumps(result, ensure_ascii=False)
     sys.stdout.buffer.write(output.encode("utf-8", errors="replace"))
+    sys.stdout.buffer.flush()
+
+
+def write_utf8_text(path: Path, text: str) -> None:
+    path.write_bytes(text.encode("utf-8", errors="replace"))
 
 
 def main() -> int:
@@ -27,21 +32,21 @@ def main() -> int:
 
         mode = payload["mode"]
         if mode == "search":
-            result = tool_search(
+            result = mcp_server.tool_search(
                 query=payload["query"],
                 limit=payload.get("limit", 5),
                 wing=payload.get("wing"),
                 room=payload.get("room"),
             )
         elif mode == "save":
-            result = tool_add_drawer(
+            result = mcp_server.tool_add_drawer(
                 wing=payload["wing"],
                 room=payload["room"],
                 content=payload["content"],
                 added_by=payload.get("added_by", "opencode"),
             )
         elif mode == "kg_add":
-            result = tool_kg_add(
+            result = mcp_server.tool_kg_add(
                 subject=payload["subject"],
                 predicate=payload["predicate"],
                 object=payload["object"],
@@ -49,7 +54,7 @@ def main() -> int:
                 source_closet=payload.get("source_closet", ""),
             )
         elif mode == "diary_write":
-            result = tool_diary_write(
+            result = mcp_server.tool_diary_write(
                 agent_name=payload["agent_name"],
                 entry=payload["entry"],
                 topic=payload.get("topic", "autosave"),
@@ -59,7 +64,7 @@ def main() -> int:
             extract_mode = payload.get("extract_mode", "general")
             with tempfile.TemporaryDirectory(prefix="mempalace-autosave-") as tmpdir:
                 transcript_path = Path(tmpdir) / "session.txt"
-                transcript_path.write_text(payload["transcript"], encoding="utf-8")
+                write_utf8_text(transcript_path, payload["transcript"])
                 with redirect_stdout(StringIO()):
                     mine_convos(
                         convo_dir=tmpdir,

package/dist/plugin/hooks/event.js

@@ -2,9 +2,11 @@ import { AutosaveReason, AutosaveStatus, buildMessageSnapshot, getMessageSnapsho
 import { executeAdapter } from "../lib/adapter";
 import { loadConfig } from "../lib/config";
 import { COMPACTION_CONTEXT_MESSAGE, DEFAULT_AGENT_NAME, LOG_MESSAGES } from "../lib/constants";
+import { sanitizeText } from "../lib/derive";
 import { getProjectName, loadSessionMessages } from "../lib/opencode";
 import { redactSecrets } from "../lib/privacy";
 import { getProjectScope } from "../lib/scope";
+import { recordAutosave } from "../lib/status";
 import { writeLog } from "../lib/log";
 import { SESSION_EVENT_TYPES } from "../lib/types";
 const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -65,6 +67,12 @@ export const eventHooks = (ctx) => {
                 });
                 if (event.type === "session.error") {
                     const failed = markFailed(sessionId);
+                    await recordAutosave({
+                        sessionId,
+                        outcome: "failed",
+                        reason: toReason(event.type),
+                        sourcePreview: getMessageSnapshot(sessionId)?.lastUserMessage,
+                    });
                     await writeLog("ERROR", LOG_MESSAGES.autosaveFailedOnSessionError, {
                         sessionId,
                         retryCount: failed.retryCount,
@@ -80,6 +88,12 @@ export const eventHooks = (ctx) => {
                 }
                 const { transcript, transcriptDigest, userDigest } = snapshot;
                 if (!shouldScheduleAutosave(sessionId, userDigest, transcriptDigest)) {
+                    await recordAutosave({
+                        sessionId,
+                        outcome: "skipped",
+                        reason: toReason(event.type),
+                        sourcePreview: snapshot.lastUserMessage,
+                    });
                     await writeLog("INFO", LOG_MESSAGES.skippingAutosaveState, {
                         sessionId,
                         reason: toReason(event.type),
@@ -89,22 +103,35 @@ export const eventHooks = (ctx) => {
                     });
                     return;
                 }
-                const redactedTranscript = redactSecrets(transcript);
-                if (!redactedTranscript.trim()) {
+                const sanitizedTranscript = sanitizeText(redactSecrets(transcript));
+                if (!sanitizedTranscript.trim()) {
                     markAutosaveComplete(sessionId, userDigest, transcriptDigest, AutosaveStatus.Noop);
+                    await recordAutosave({
+                        sessionId,
+                        outcome: "skipped",
+                        reason: toReason(event.type),
+                        sourcePreview: snapshot.lastUserMessage,
+                    });
                     await writeLog("INFO", LOG_MESSAGES.autosaveSkippedEmptyTranscript, { sessionId });
                     return;
                 }
                 const wing = getProjectScope(getProjectName(ctx.project), config.projectWingPrefix).wing;
                 const result = await executeAdapter(ctx.$, {
                     mode: "mine_messages",
-                    transcript: redactedTranscript,
+                    transcript: sanitizedTranscript,
                     wing,
                     extract_mode: config.autoMineExtractMode,
                     agent: DEFAULT_AGENT_NAME,
                 });
                 if (result?.success === false) {
                     const failed = markFailed(sessionId);
+                    await recordAutosave({
+                        sessionId,
+                        outcome: "failed",
+                        reason: toReason(event.type),
+                        wing,
+                        sourcePreview: snapshot.lastUserMessage,
+                    });
                     await writeLog("ERROR", LOG_MESSAGES.autosaveMiningFailed, {
                         sessionId,
                         retryCount: failed.retryCount,
@@ -113,6 +140,13 @@ export const eventHooks = (ctx) => {
                     return;
                 }
                 const completed = markAutosaveComplete(sessionId, userDigest, transcriptDigest, AutosaveStatus.Saved);
+                await recordAutosave({
+                    sessionId,
+                    outcome: "saved",
+                    reason: toReason(event.type),
+                    wing,
+                    sourcePreview: snapshot.lastUserMessage,
+                });
                 await writeLog("INFO", LOG_MESSAGES.autosaveMinedSessionContext, {
                     sessionId,
                     reason: toReason(event.type),

package/dist/plugin/hooks/system.js

@@ -4,6 +4,7 @@ import { LOG_MESSAGES } from "../lib/constants";
 import { buildKeywordSaveInstruction, buildRetrievalInstruction } from "../lib/context";
 import { writeLog } from "../lib/log";
 import { getProjectName, loadSessionMessages } from "../lib/opencode";
+import { recordRetrievalPrompt } from "../lib/status";
 export const systemHooks = (ctx) => {
     return {
         "experimental.chat.system.transform": async (input, output) => {
@@ -29,6 +30,7 @@ export const systemHooks = (ctx) => {
                         lastUserMessage,
                     }));
                     markRetrievalInjected(sessionId);
+                    await recordRetrievalPrompt({ sessionId, queryPreview: lastUserMessage });
                     await writeLog("INFO", LOG_MESSAGES.injectedRetrievalInstruction, { sessionId });
                 }
                 if (state.keywordSavePending) {

package/dist/plugin/index.js

@@ -3,6 +3,7 @@ import { systemHooks } from "./hooks/system";
 import { toolHooks } from "./hooks/tool";
 import { setLogger } from "./lib/log";
 import { mempalaceMemoryTool } from "./tools/mempalace-memory";
+import { mempalaceStatusTool } from "./tools/mempalace-status";
 export const MempalaceAutosavePlugin = async (ctx) => {
     setLogger(ctx.client);
     return {
@@ -11,6 +12,7 @@ export const MempalaceAutosavePlugin = async (ctx) => {
         ...toolHooks(),
         tool: {
             mempalace_memory: mempalaceMemoryTool(ctx),
+            mempalace_status: mempalaceStatusTool(),
         },
     };
 };

package/dist/plugin/lib/adapter.js

@@ -17,12 +17,18 @@ const getAdapterTimeoutMs = () => {
 const isAdapterResponse = (value) => {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 };
+const getStderrSnippet = (value) => {
+    const normalized = value.trim();
+    if (!normalized)
+        return "";
+    return normalized.length > 240 ? `${normalized.slice(0, 240)}...` : normalized;
+};
 export const executeAdapter = async (_shell, payload, retries = 3) => {
     let lastError;
     const timeoutMs = getAdapterTimeoutMs();
     for (let attempt = 0; attempt <= retries; attempt += 1) {
         try {
-            const text = await new Promise((resolve, reject) => {
+            const { stderrText, stdoutText } = await new Promise((resolve, reject) => {
                 const child = spawn(getPythonCommand(), [getAdapterPath()], {
                     stdio: ["pipe", "pipe", "pipe"],
                 });
@@ -48,17 +54,25 @@ export const executeAdapter = async (_shell, payload, retries = 3) => {
                 child.on("error", (error) => finish(() => reject(error)));
                 child.on("close", (code) => {
                     finish(() => {
+                        const stderrText = Buffer.concat(stderr).toString("utf8");
+                        const stdoutText = Buffer.concat(stdout).toString("utf8");
                         if (code === 0) {
-                            resolve(Buffer.concat(stdout).toString("utf8"));
+                            resolve({ stderrText, stdoutText });
                             return;
                         }
-                        reject(new Error(Buffer.concat(stderr).toString("utf8") || `Adapter exited with code ${code}`));
+                        reject(new Error(stderrText || `Adapter exited with code ${code}`));
                     });
                 });
                 child.stdin.write(JSON.stringify(payload), "utf8");
                 child.stdin.end();
             });
-            const parsed = JSON.parse(text);
+            if (!stdoutText.trim()) {
+                const stderrSnippet = getStderrSnippet(stderrText);
+                throw new Error(stderrSnippet
+                    ? `${TOOL_ERROR_MESSAGES.emptyAdapterStdout}: ${stderrSnippet}`
+                    : TOOL_ERROR_MESSAGES.emptyAdapterStdout);
+            }
+            const parsed = JSON.parse(stdoutText);
             if (!isAdapterResponse(parsed)) {
                 throw new Error(TOOL_ERROR_MESSAGES.invalidAdapterPayload);
             }

package/dist/plugin/lib/constants.d.ts

@@ -21,6 +21,7 @@ export declare const ENV_KEYS: {
     readonly userWingPrefix: "MEMPALACE_USER_WING_PREFIX";
     readonly projectWingPrefix: "MEMPALACE_PROJECT_WING_PREFIX";
     readonly autosaveLogFile: "MEMPALACE_AUTOSAVE_LOG_FILE";
+    readonly statusFile: "MEMPALACE_STATUS_FILE";
     readonly adapterPython: "MEMPALACE_ADAPTER_PYTHON";
     readonly adapterTimeoutMs: "MEMPALACE_ADAPTER_TIMEOUT_MS";
 };
@@ -29,14 +30,17 @@ export declare const MAX_TRANSCRIPT_MESSAGES_DIGEST: 50;
 export declare const DATE_ISO_SLICE: 10;
 export declare const SERVICE_NAME: "mempalace-autosave";
 export declare const LOG_FILE_NAME: "opencode_autosave.log";
+export declare const STATUS_FILE_NAME: "opencode_status.json";
 export declare const DIRECT_MEMPALACE_MUTATION_TOOLS: readonly ["mempalace_add_drawer", "mempalace_kg_add", "mempalace_diary_write", "mcp-router_mempalace_add_drawer", "mcp-router_mempalace_kg_add", "mcp-router_mempalace_diary_write"];
 export declare const COMPACTION_CONTEXT_MESSAGE: "MemPalace retrieval may be useful after compaction. Search relevant project and user memory if needed before answering.";
 export declare const TOOL_DESCRIPTIONS: {
     readonly mempalaceMemory: "Save or search memory in MemPalace with scope/privacy enforcement";
+    readonly mempalaceStatus: "Show recent visible evidence that MemPalace retrieval or autosave helped";
 };
 export declare const TOOL_ERROR_MESSAGES: {
     readonly directMutationBlocked: "Use mempalace_memory instead of direct MemPalace mutation tools";
     readonly invalidAdapterPayload: "Adapter returned an invalid JSON payload";
+    readonly emptyAdapterStdout: "Adapter returned empty stdout";
     readonly adapterTimedOut: "Adapter execution timed out";
 };
 export declare const LOG_MESSAGES: {

package/dist/plugin/lib/constants.js

@@ -21,6 +21,7 @@ export const ENV_KEYS = {
     userWingPrefix: "MEMPALACE_USER_WING_PREFIX",
     projectWingPrefix: "MEMPALACE_PROJECT_WING_PREFIX",
     autosaveLogFile: "MEMPALACE_AUTOSAVE_LOG_FILE",
+    statusFile: "MEMPALACE_STATUS_FILE",
     adapterPython: "MEMPALACE_ADAPTER_PYTHON",
     adapterTimeoutMs: "MEMPALACE_ADAPTER_TIMEOUT_MS",
 };
@@ -29,6 +30,7 @@ export const MAX_TRANSCRIPT_MESSAGES_DIGEST = 50;
 export const DATE_ISO_SLICE = 10;
 export const SERVICE_NAME = "mempalace-autosave";
 export const LOG_FILE_NAME = "opencode_autosave.log";
+export const STATUS_FILE_NAME = "opencode_status.json";
 export const DIRECT_MEMPALACE_MUTATION_TOOLS = [
     "mempalace_add_drawer",
     "mempalace_kg_add",
@@ -40,10 +42,12 @@ export const DIRECT_MEMPALACE_MUTATION_TOOLS = [
 export const COMPACTION_CONTEXT_MESSAGE = "MemPalace retrieval may be useful after compaction. Search relevant project and user memory if needed before answering.";
 export const TOOL_DESCRIPTIONS = {
     mempalaceMemory: "Save or search memory in MemPalace with scope/privacy enforcement",
+    mempalaceStatus: "Show recent visible evidence that MemPalace retrieval or autosave helped",
 };
 export const TOOL_ERROR_MESSAGES = {
     directMutationBlocked: "Use mempalace_memory instead of direct MemPalace mutation tools",
     invalidAdapterPayload: "Adapter returned an invalid JSON payload",
+    emptyAdapterStdout: "Adapter returned empty stdout",
     adapterTimedOut: "Adapter execution timed out",
 };
 export const LOG_MESSAGES = {

package/dist/plugin/lib/status.d.ts

@@ -0,0 +1,105 @@
+import type { AdapterResponse, MemoryScope } from "./types";
+export type StatusCounters = {
+    retrievalPrompts: number;
+    retrievalSearches: number;
+    retrievalHits: number;
+    autosavesCompleted: number;
+    autosavesSkipped: number;
+    autosavesFailed: number;
+    manualWrites: number;
+};
+export type StatusSessionCounters = {
+    retrievalSearches: number;
+    retrievalHits: number;
+    autosavesCompleted: number;
+    autosavesSkipped: number;
+    autosavesFailed: number;
+    manualWrites: number;
+};
+export type StatusRetrievalPrompt = {
+    sessionId?: string;
+    timestamp: string;
+    queryPreview: string;
+};
+export type StatusRetrieval = {
+    sessionId?: string;
+    timestamp: string;
+    scope: MemoryScope;
+    room?: string;
+    queryPreview: string;
+    resultCount?: number;
+    previews: string[];
+};
+export type StatusAutosaveOutcome = "saved" | "skipped" | "failed";
+export type StatusAutosave = {
+    sessionId: string;
+    timestamp: string;
+    outcome: StatusAutosaveOutcome;
+    reason: string;
+    wing?: string;
+    sourcePreview?: string;
+};
+export type StatusWrite = {
+    timestamp: string;
+    mode: "save" | "kg_add" | "diary_write";
+    scope?: MemoryScope;
+    room?: string;
+    preview: string;
+};
+export type StatusSessionState = {
+    updatedAt: string;
+    counters: StatusSessionCounters;
+    lastRetrievalPrompt?: StatusRetrievalPrompt;
+    lastRetrieval?: StatusRetrieval;
+    lastAutosave?: StatusAutosave;
+    lastWrite?: StatusWrite;
+};
+export type StatusState = {
+    version: 2;
+    updatedAt: string;
+    counters: StatusCounters;
+    helpedSessionIds: string[];
+    sessions: Record<string, StatusSessionState>;
+    lastRetrievalPrompt?: StatusRetrievalPrompt;
+    lastRetrieval?: StatusRetrieval;
+    lastAutosave?: StatusAutosave;
+    lastWrite?: StatusWrite;
+};
+type SearchResultSummary = {
+    resultCount?: number;
+    previews: string[];
+};
+export declare const summarizeSearchResult: (result: AdapterResponse) => SearchResultSummary;
+export declare const recordRetrievalPrompt: (input: {
+    sessionId?: string;
+    queryPreview: string;
+}) => Promise<void>;
+export declare const recordRetrievalSearch: (input: {
+    sessionId?: string;
+    scope: MemoryScope;
+    room?: string;
+    query: string;
+    result: AdapterResponse;
+}) => Promise<void>;
+export declare const recordMemoryWrite: (input: {
+    sessionId?: string;
+    mode: "save" | "kg_add" | "diary_write";
+    scope?: MemoryScope;
+    room?: string;
+    preview: string;
+}) => Promise<void>;
+export declare const recordAutosave: (input: {
+    sessionId: string;
+    outcome: StatusAutosaveOutcome;
+    reason: string;
+    wing?: string;
+    sourcePreview?: string;
+}) => Promise<void>;
+export declare const readStatusState: () => Promise<StatusState>;
+export declare const resetStatusState: () => Promise<void>;
+export declare const formatSessionHud: (state: StatusState, sessionId: string) => string;
+export declare const formatStatusSummary: (state: StatusState, sessionId?: string, options?: {
+    verbose?: boolean;
+    compact?: boolean;
+}) => string;
+export {};