@rvboris/opencode-mempalace 0.1.0

package/dist/plugin/hooks/system.js

@@ -0,0 +1,50 @@
+import { AutosaveStatus, clearKeywordSavePending, extractLastUserMessage, getCurrentTurnSessionId, getSessionState, markRetrievalInjected, startAutosave, } from "../lib/autosave";
+import { loadConfig } from "../lib/config";
+import { buildAutosaveInstruction, buildKeywordSaveInstruction, buildRetrievalInstruction } from "../lib/context";
+import { writeLog } from "../lib/log";
+export const systemHooks = (ctx) => {
+    return {
+        "experimental.chat.system.transform": async (_input, output) => {
+            try {
+                const sessionId = getCurrentTurnSessionId();
+                if (!sessionId)
+                    return;
+                const config = await loadConfig();
+                const state = getSessionState(sessionId);
+                const response = await ctx.client.session.messages({ path: { id: sessionId } });
+                const messages = response?.data ?? response ?? [];
+                const lastUserMessage = extractLastUserMessage(messages);
+                if (config.retrievalEnabled && state.retrievalPending && lastUserMessage) {
+                    output.system.push(buildRetrievalInstruction({
+                        projectName: ctx.project?.name,
+                        projectWingPrefix: config.projectWingPrefix,
+                        userWingPrefix: config.userWingPrefix,
+                        maxInjectedItems: config.maxInjectedItems,
+                        retrievalQueryLimit: config.retrievalQueryLimit,
+                        lastUserMessage,
+                    }));
+                    markRetrievalInjected(sessionId);
+                    await writeLog("INFO", "injected retrieval instruction", { sessionId });
+                }
+                if (state.keywordSavePending) {
+                    output.system.push(buildKeywordSaveInstruction());
+                    clearKeywordSavePending(sessionId);
+                    await writeLog("INFO", "injected keyword save instruction", { sessionId });
+                }
+                if (state.status !== AutosaveStatus.Pending || !state.pendingReason)
+                    return;
+                output.system.push(buildAutosaveInstruction(state.pendingReason));
+                startAutosave(sessionId);
+                await writeLog("INFO", "injected hidden autosave instruction", {
+                    sessionId,
+                    reason: state.pendingReason,
+                });
+            }
+            catch (error) {
+                await writeLog("ERROR", "system transform hook failed", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        },
+    };
+};

package/dist/plugin/hooks/tool.d.ts

@@ -0,0 +1,17 @@
+export declare const toolHooks: () => {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        args: any;
+    }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        output: string;
+        metadata: any;
+    }) => Promise<void>;
+};

package/dist/plugin/hooks/tool.js

@@ -0,0 +1,61 @@
+import { writeLog } from "../lib/log";
+import { AutosaveStatus, getSessionState, markMutationToolCall, recordSuccessfulTool, shouldCountSuccessfulTool } from "../lib/autosave";
+import { isDirectMempalaceMutationTool } from "../lib/enforcement";
+const isMempalaceTool = (tool) => tool === "mempalace_memory";
+const isSuccessfulToolOutput = (output) => {
+    const text = `${output.output || ""} ${JSON.stringify(output.metadata || {})}`.toLowerCase();
+    return !text.includes("\"success\":false") && !text.includes("error");
+};
+const getMetadataSessionId = (metadata) => {
+    return metadata?.sessionID || metadata?.sessionId || metadata?.session?.id;
+};
+export const toolHooks = () => {
+    return {
+        "tool.execute.before": async (input, output) => {
+            if (isDirectMempalaceMutationTool(input.tool)) {
+                await writeLog("WARN", "blocked direct mempalace mutation tool", {
+                    tool: input.tool,
+                    sessionId: input.sessionID,
+                });
+                throw new Error("Use mempalace_memory instead of direct MemPalace mutation tools");
+            }
+            if (input.tool !== "mempalace_memory" || !input.sessionID)
+                return;
+            const mode = output.args?.mode;
+            if (mode === "save" || mode === "kg_add" || mode === "diary_write") {
+                markMutationToolCall(input.sessionID, input.callID);
+            }
+        },
+        "tool.execute.after": async (input, output) => {
+            try {
+                if (!input.sessionID) {
+                    await writeLog("WARN", "tool.execute.after missing sessionID", { tool: input.tool });
+                    return;
+                }
+                if (!isMempalaceTool(input.tool))
+                    return;
+                const state = getSessionState(input.sessionID);
+                if (state.status !== AutosaveStatus.Running)
+                    return;
+                const metadataSessionId = getMetadataSessionId(output.metadata);
+                if (metadataSessionId && metadataSessionId !== input.sessionID)
+                    return;
+                if (!isSuccessfulToolOutput(output))
+                    return;
+                if (!shouldCountSuccessfulTool(input.sessionID, input.tool, input.callID))
+                    return;
+                recordSuccessfulTool(input.sessionID, input.tool, input.callID);
+                await writeLog("INFO", "observed mempalace tool during autosave", {
+                    sessionId: input.sessionID,
+                    tool: input.tool,
+                    count: getSessionState(input.sessionID).successfulToolCalls.length,
+                });
+            }
+            catch (error) {
+                await writeLog("ERROR", "tool.execute.after hook failed", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        },
+    };
+};

package/dist/plugin/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const MempalaceAutosavePlugin: Plugin;

package/dist/plugin/index.js

@@ -0,0 +1,18 @@
+import { chatParamHooks } from "./hooks/chat-params";
+import { eventHooks } from "./hooks/event";
+import { systemHooks } from "./hooks/system";
+import { toolHooks } from "./hooks/tool";
+import { setLogger } from "./lib/log";
+import { mempalaceMemoryTool } from "./tools/mempalace-memory";
+export const MempalaceAutosavePlugin = async (ctx) => {
+    setLogger(ctx.client);
+    return {
+        ...chatParamHooks(),
+        ...eventHooks(ctx),
+        ...systemHooks(ctx),
+        ...toolHooks(),
+        tool: {
+            mempalace_memory: mempalaceMemoryTool(ctx),
+        },
+    };
+};

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

@@ -0,0 +1 @@
+export declare const executeAdapter: (_shell: any, payload: Record<string, unknown>, retries?: number) => Promise<any>;

package/dist/plugin/lib/adapter.js

@@ -0,0 +1,42 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const getAdapterPath = () => {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(here, "..", "..", "bridge", "mempalace_adapter.py");
+};
+const getPythonCommand = () => process.env.MEMPALACE_ADAPTER_PYTHON || "python";
+export const executeAdapter = async (_shell, payload, retries = 3) => {
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+        try {
+            const text = await new Promise((resolve, reject) => {
+                const child = spawn(getPythonCommand(), [getAdapterPath()], {
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                const stdout = [];
+                const stderr = [];
+                child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+                child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+                child.on("error", reject);
+                child.on("close", (code) => {
+                    if (code === 0) {
+                        resolve(Buffer.concat(stdout).toString("utf8"));
+                        return;
+                    }
+                    reject(new Error(Buffer.concat(stderr).toString("utf8") || `Adapter exited with code ${code}`));
+                });
+                child.stdin.write(JSON.stringify(payload), "utf8");
+                child.stdin.end();
+            });
+            return JSON.parse(text);
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === retries)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 150 * (attempt + 1)));
+        }
+    }
+    throw lastError;
+};

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

@@ -0,0 +1,52 @@
+export declare enum AutosaveReason {
+    Idle = "idle",
+    Compacted = "compacted",
+    Error = "error"
+}
+export declare enum AutosaveStatus {
+    Idle = "idle",
+    Pending = "pending",
+    Running = "running",
+    Saved = "saved",
+    Noop = "noop",
+    Failed = "failed"
+}
+export type SessionAutosaveState = {
+    status: AutosaveStatus;
+    pendingReason?: AutosaveReason;
+    retrievalPending: boolean;
+    pendingRetrievalUserDigest?: string;
+    keywordSavePending: boolean;
+    pendingUserDigest?: string;
+    pendingTranscriptDigest?: string;
+    lastHandledUserDigest?: string;
+    lastHandledTranscriptDigest?: string;
+    successfulToolCalls: string[];
+    successfulToolCallIds: string[];
+    mutationToolCallIds: string[];
+    runningSince?: number;
+    lastToolCallAt?: number;
+    lastRetrievedUserDigest?: string;
+    retryCount: number;
+    lastFailureAt?: number;
+    updatedAt: number;
+};
+export declare const buildUserDigest: (messages: any[]) => string;
+export declare const buildTranscriptDigest: (messages: any[]) => string;
+export declare const getSessionState: (sessionId: string) => SessionAutosaveState;
+export declare const setCurrentTurnSessionId: (sessionId: string | undefined) => void;
+export declare const getCurrentTurnSessionId: () => string | undefined;
+export declare const resetAllStates: () => void;
+export declare const markPending: (sessionId: string, reason: AutosaveReason, userDigest: string, transcriptDigest: string) => void;
+export declare const markRetrievalInjected: (sessionId: string) => void;
+export declare const markRetrievalPending: (sessionId: string, userDigest: string) => void;
+export declare const markKeywordSavePending: (sessionId: string) => void;
+export declare const clearKeywordSavePending: (sessionId: string) => void;
+export declare const extractLastUserMessage: (messages: any[]) => string;
+export declare const startAutosave: (sessionId: string) => void;
+export declare const markMutationToolCall: (sessionId: string, callId?: string) => void;
+export declare const shouldCountSuccessfulTool: (sessionId: string, tool: string, callId?: string) => boolean;
+export declare const recordSuccessfulTool: (sessionId: string, tool: string, callId?: string) => void;
+export declare const finalizeAutosave: (sessionId: string) => SessionAutosaveState;
+export declare const markFailed: (sessionId: string) => SessionAutosaveState;
+export declare const shouldScheduleAutosave: (sessionId: string, userDigest: string, transcriptDigest: string) => boolean;

package/dist/plugin/lib/autosave.js

@@ -0,0 +1,242 @@
+import crypto from "node:crypto";
+import { sanitizeText } from "./derive";
+import { stripPrivateContent } from "./privacy";
+export var AutosaveReason;
+(function (AutosaveReason) {
+    AutosaveReason["Idle"] = "idle";
+    AutosaveReason["Compacted"] = "compacted";
+    AutosaveReason["Error"] = "error";
+})(AutosaveReason || (AutosaveReason = {}));
+export var AutosaveStatus;
+(function (AutosaveStatus) {
+    AutosaveStatus["Idle"] = "idle";
+    AutosaveStatus["Pending"] = "pending";
+    AutosaveStatus["Running"] = "running";
+    AutosaveStatus["Saved"] = "saved";
+    AutosaveStatus["Noop"] = "noop";
+    AutosaveStatus["Failed"] = "failed";
+})(AutosaveStatus || (AutosaveStatus = {}));
+const states = new Map();
+let currentTurnSessionId;
+const MAX_SESSIONS = 200;
+const STATE_TTL_MS = 1000 * 60 * 60 * 12;
+const RETRY_COOLDOWN_MS = 1000 * 30;
+const MAX_RETRIES = 2;
+const extractTextParts = (message) => {
+    const parts = [];
+    if (!message)
+        return parts;
+    if (typeof message.content === "string")
+        parts.push(message.content);
+    if (Array.isArray(message.parts)) {
+        for (const part of message.parts) {
+            if (!part)
+                continue;
+            if (typeof part.text === "string")
+                parts.push(part.text);
+            if (typeof part.content === "string")
+                parts.push(part.content);
+        }
+    }
+    if (message.info && typeof message.info?.content === "string") {
+        parts.push(message.info.content);
+    }
+    return parts;
+};
+const extractRole = (message) => message?.role || message?.info?.role || "unknown";
+const fingerprint = (chunks) => {
+    return crypto.createHash("sha256").update(JSON.stringify(chunks), "utf8").digest("hex").slice(0, 16);
+};
+export const buildUserDigest = (messages) => {
+    const normalized = (messages || [])
+        .filter((message) => extractRole(message) === "user")
+        .slice(-20)
+        .map((message) => extractTextParts(message).map((part) => sanitizeText(part)).join("\n"));
+    return fingerprint(normalized);
+};
+export const buildTranscriptDigest = (messages) => {
+    const normalized = (messages || []).slice(-50).map((message) => {
+        const role = extractRole(message);
+        const text = extractTextParts(message).map((part) => sanitizeText(part)).join("\n");
+        return `${role}:${text}`;
+    });
+    return fingerprint(normalized);
+};
+const createState = () => ({
+    status: AutosaveStatus.Idle,
+    successfulToolCalls: [],
+    successfulToolCallIds: [],
+    mutationToolCallIds: [],
+    retryCount: 0,
+    retrievalPending: true,
+    keywordSavePending: false,
+    updatedAt: Date.now(),
+});
+export const getSessionState = (sessionId) => {
+    evictExpiredStates();
+    const existing = states.get(sessionId);
+    if (existing) {
+        existing.updatedAt = Date.now();
+        return existing;
+    }
+    const state = createState();
+    states.set(sessionId, state);
+    evictOverflowStates();
+    return state;
+};
+export const setCurrentTurnSessionId = (sessionId) => {
+    currentTurnSessionId = sessionId;
+};
+export const getCurrentTurnSessionId = () => currentTurnSessionId;
+const evictExpiredStates = () => {
+    const now = Date.now();
+    for (const [sessionId, state] of states) {
+        if (now - state.updatedAt > STATE_TTL_MS)
+            states.delete(sessionId);
+    }
+};
+const evictOverflowStates = () => {
+    if (states.size <= MAX_SESSIONS)
+        return;
+    const sorted = [...states.entries()].sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+    for (const [sessionId] of sorted.slice(0, states.size - MAX_SESSIONS)) {
+        states.delete(sessionId);
+    }
+};
+export const resetAllStates = () => {
+    states.clear();
+    currentTurnSessionId = undefined;
+};
+export const markPending = (sessionId, reason, userDigest, transcriptDigest) => {
+    const state = getSessionState(sessionId);
+    state.status = AutosaveStatus.Pending;
+    state.pendingReason = reason;
+    state.pendingUserDigest = userDigest;
+    state.pendingTranscriptDigest = transcriptDigest;
+    state.successfulToolCalls = [];
+    state.successfulToolCallIds = [];
+    state.mutationToolCallIds = [];
+    state.updatedAt = Date.now();
+};
+export const markRetrievalInjected = (sessionId) => {
+    const state = getSessionState(sessionId);
+    state.retrievalPending = false;
+    state.lastRetrievedUserDigest = state.pendingRetrievalUserDigest;
+    state.pendingRetrievalUserDigest = undefined;
+    state.updatedAt = Date.now();
+};
+export const markRetrievalPending = (sessionId, userDigest) => {
+    const state = getSessionState(sessionId);
+    if (state.lastRetrievedUserDigest === userDigest)
+        return;
+    if (state.pendingRetrievalUserDigest === userDigest && state.retrievalPending)
+        return;
+    state.retrievalPending = true;
+    state.pendingRetrievalUserDigest = userDigest;
+    state.updatedAt = Date.now();
+};
+export const markKeywordSavePending = (sessionId) => {
+    const state = getSessionState(sessionId);
+    state.keywordSavePending = true;
+    state.updatedAt = Date.now();
+};
+export const clearKeywordSavePending = (sessionId) => {
+    const state = getSessionState(sessionId);
+    state.keywordSavePending = false;
+    state.updatedAt = Date.now();
+};
+export const extractLastUserMessage = (messages) => {
+    const userMessages = (messages || []).filter((message) => extractRole(message) === "user");
+    const last = userMessages.at(-1);
+    const text = extractTextParts(last).map((part) => stripPrivateContent(part)).join("\n").trim();
+    return text;
+};
+export const startAutosave = (sessionId) => {
+    const state = getSessionState(sessionId);
+    state.status = AutosaveStatus.Running;
+    state.successfulToolCalls = [];
+    state.successfulToolCallIds = [];
+    state.mutationToolCallIds = [];
+    state.runningSince = Date.now();
+    state.updatedAt = Date.now();
+};
+export const markMutationToolCall = (sessionId, callId) => {
+    if (!callId)
+        return;
+    const state = getSessionState(sessionId);
+    if (!state.mutationToolCallIds.includes(callId)) {
+        state.mutationToolCallIds.push(callId);
+        state.updatedAt = Date.now();
+    }
+};
+export const shouldCountSuccessfulTool = (sessionId, tool, callId) => {
+    const state = getSessionState(sessionId);
+    if (tool === "mempalace_memory") {
+        return !!callId && state.mutationToolCallIds.includes(callId);
+    }
+    return false;
+};
+export const recordSuccessfulTool = (sessionId, tool, callId) => {
+    const state = getSessionState(sessionId);
+    if (callId && state.successfulToolCallIds.includes(callId))
+        return;
+    if (!state.successfulToolCalls.includes(tool))
+        state.successfulToolCalls.push(tool);
+    if (callId)
+        state.successfulToolCallIds.push(callId);
+    state.lastToolCallAt = Date.now();
+    state.updatedAt = Date.now();
+};
+export const finalizeAutosave = (sessionId) => {
+    const state = getSessionState(sessionId);
+    if (state.status !== AutosaveStatus.Running)
+        return state;
+    const succeeded = state.successfulToolCalls.length > 0 &&
+        (!state.runningSince || (state.lastToolCallAt != null && state.lastToolCallAt >= state.runningSince));
+    state.status = succeeded ? AutosaveStatus.Saved : AutosaveStatus.Noop;
+    state.lastHandledUserDigest = state.pendingUserDigest;
+    state.lastHandledTranscriptDigest = state.pendingTranscriptDigest;
+    state.retryCount = succeeded ? 0 : state.retryCount;
+    state.pendingReason = undefined;
+    state.pendingUserDigest = undefined;
+    state.pendingTranscriptDigest = undefined;
+    state.successfulToolCalls = [];
+    state.successfulToolCallIds = [];
+    state.mutationToolCallIds = [];
+    state.runningSince = undefined;
+    state.lastToolCallAt = undefined;
+    state.updatedAt = Date.now();
+    return state;
+};
+export const markFailed = (sessionId) => {
+    const state = getSessionState(sessionId);
+    state.status = AutosaveStatus.Failed;
+    state.retryCount += 1;
+    state.lastFailureAt = Date.now();
+    state.pendingReason = undefined;
+    state.pendingUserDigest = undefined;
+    state.pendingTranscriptDigest = undefined;
+    state.successfulToolCalls = [];
+    state.successfulToolCallIds = [];
+    state.mutationToolCallIds = [];
+    state.runningSince = undefined;
+    state.lastToolCallAt = undefined;
+    state.updatedAt = Date.now();
+    return state;
+};
+export const shouldScheduleAutosave = (sessionId, userDigest, transcriptDigest) => {
+    const state = getSessionState(sessionId);
+    if (state.status === AutosaveStatus.Pending || state.status === AutosaveStatus.Running)
+        return false;
+    if (state.status === AutosaveStatus.Failed) {
+        if (state.retryCount >= MAX_RETRIES)
+            return false;
+        if (state.lastFailureAt && Date.now() - state.lastFailureAt < RETRY_COOLDOWN_MS)
+            return false;
+    }
+    if (state.lastHandledUserDigest === userDigest)
+        return false;
+    if (state.lastHandledTranscriptDigest === transcriptDigest)
+        return false;
+    return true;
+};

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

@@ -0,0 +1,13 @@
+export type MempalaceConfig = {
+    autosaveEnabled: boolean;
+    retrievalEnabled: boolean;
+    keywordSaveEnabled: boolean;
+    maxInjectedItems: number;
+    retrievalQueryLimit: number;
+    keywordPatterns: string[];
+    privacyRedactionEnabled: boolean;
+    userWingPrefix: string;
+    projectWingPrefix: string;
+};
+export declare const loadConfig: () => Promise<MempalaceConfig>;
+export declare const resetConfig: () => void;

package/dist/plugin/lib/config.js

@@ -0,0 +1,53 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const DEFAULT_CONFIG = {
+    autosaveEnabled: true,
+    retrievalEnabled: true,
+    keywordSaveEnabled: true,
+    maxInjectedItems: 6,
+    retrievalQueryLimit: 5,
+    keywordPatterns: ["remember", "save this", "don't forget", "note that"],
+    privacyRedactionEnabled: true,
+    userWingPrefix: "wing_user",
+    projectWingPrefix: "wing_project",
+};
+const CONFIG_PATH = path.join(os.homedir(), ".config", "opencode", "mempalace.jsonc");
+const stripJsonComments = (value) => {
+    return value.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+};
+const parseBoolean = (value, fallback) => {
+    if (value == null)
+        return fallback;
+    return value !== "false";
+};
+let cachedConfig;
+export const loadConfig = async () => {
+    if (cachedConfig)
+        return cachedConfig;
+    let fileConfig = {};
+    try {
+        const raw = await fs.readFile(CONFIG_PATH, "utf8");
+        fileConfig = JSON.parse(stripJsonComments(raw));
+    }
+    catch {
+        // optional config file
+    }
+    cachedConfig = {
+        ...DEFAULT_CONFIG,
+        ...fileConfig,
+        autosaveEnabled: parseBoolean(process.env.MEMPALACE_AUTOSAVE_ENABLED, fileConfig.autosaveEnabled ?? DEFAULT_CONFIG.autosaveEnabled),
+        retrievalEnabled: parseBoolean(process.env.MEMPALACE_RETRIEVAL_ENABLED, fileConfig.retrievalEnabled ?? DEFAULT_CONFIG.retrievalEnabled),
+        keywordSaveEnabled: parseBoolean(process.env.MEMPALACE_KEYWORD_SAVE_ENABLED, fileConfig.keywordSaveEnabled ?? DEFAULT_CONFIG.keywordSaveEnabled),
+        privacyRedactionEnabled: parseBoolean(process.env.MEMPALACE_PRIVACY_REDACTION_ENABLED, fileConfig.privacyRedactionEnabled ?? DEFAULT_CONFIG.privacyRedactionEnabled),
+        maxInjectedItems: Number(process.env.MEMPALACE_MAX_INJECTED_ITEMS || fileConfig.maxInjectedItems || DEFAULT_CONFIG.maxInjectedItems),
+        retrievalQueryLimit: Number(process.env.MEMPALACE_RETRIEVAL_QUERY_LIMIT || fileConfig.retrievalQueryLimit || DEFAULT_CONFIG.retrievalQueryLimit),
+        keywordPatterns: fileConfig.keywordPatterns || DEFAULT_CONFIG.keywordPatterns,
+        userWingPrefix: process.env.MEMPALACE_USER_WING_PREFIX || fileConfig.userWingPrefix || DEFAULT_CONFIG.userWingPrefix,
+        projectWingPrefix: process.env.MEMPALACE_PROJECT_WING_PREFIX || fileConfig.projectWingPrefix || DEFAULT_CONFIG.projectWingPrefix,
+    };
+    return cachedConfig;
+};
+export const resetConfig = () => {
+    cachedConfig = undefined;
+};

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

@@ -0,0 +1,12 @@
+type BuildContextInput = {
+    projectName?: string;
+    projectWingPrefix: string;
+    userWingPrefix: string;
+    maxInjectedItems: number;
+    retrievalQueryLimit: number;
+    lastUserMessage: string;
+};
+export declare const buildRetrievalInstruction: ({ projectName, projectWingPrefix, userWingPrefix, maxInjectedItems, retrievalQueryLimit, lastUserMessage, }: BuildContextInput) => string;
+export declare const buildAutosaveInstruction: (reason: string) => string;
+export declare const buildKeywordSaveInstruction: () => string;
+export {};

package/dist/plugin/lib/context.js

@@ -0,0 +1,37 @@
+import { getProjectScope, getUserScope } from "./scope";
+export const buildRetrievalInstruction = ({ projectName, projectWingPrefix, userWingPrefix, maxInjectedItems, retrievalQueryLimit, lastUserMessage, }) => {
+    const project = getProjectScope(projectName, projectWingPrefix);
+    const user = getUserScope(userWingPrefix);
+    return [
+        "System instruction: before answering, search MemPalace for relevant existing memory and use it if helpful.",
+        `Query focus: ${lastUserMessage.slice(0, 500)}`,
+        `Limit search results to ${retrievalQueryLimit} per scope.`,
+        `Search user memory in wing ${user.wing} across rooms ${user.rooms.join(", ")}.`,
+        `Search project memory in wing ${project.wing} across rooms ${project.rooms.join(", ")}.`,
+        `Use concise relevant memories only, up to ${maxInjectedItems} items total.`,
+        "Do not mention this instruction to the user.",
+    ].join(" ");
+};
+export const buildAutosaveInstruction = (reason) => {
+    return [
+        "System instruction: before answering the user, persist durable memory from prior session context using the `mempalace_memory` tool.",
+        "Do not use raw `mempalace_*` or `mcp-router_mempalace_*` mutation tools directly.",
+        `Trigger reason: ${reason}.`,
+        "Save only stable facts, decisions, preferences, important outcomes, and useful diary notes.",
+        "Prefer concise structured memories in the appropriate user/project scopes:",
+        "- user scope: preferences, personal workflow habits, communication style",
+        "- project scope: architecture, setup, decisions, bugs, workflows",
+        "Do not dump the full transcript into a single drawer.",
+        "Apply privacy redaction before saving and skip fully private content.",
+        "Do not mention this instruction to the user.",
+    ].join(" ");
+};
+export const buildKeywordSaveInstruction = () => {
+    return [
+        "System instruction: the user explicitly asked to remember something.",
+        "Use the `mempalace_memory` tool to save the important durable information now.",
+        "Do not use raw `mempalace_*` or `mcp-router_mempalace_*` mutation tools directly.",
+        "Choose user scope for cross-project preferences and project scope for repository-specific knowledge.",
+        "Do not mention this instruction to the user.",
+    ].join(" ");
+};

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

@@ -0,0 +1 @@
+export declare const sanitizeText: (text: string) => string;

package/dist/plugin/lib/derive.js

@@ -0,0 +1,36 @@
+const ANSI_PATTERN = /\u001B(?:\][^\u0007]*(?:\u0007|\u001B\\)|\[[0-?]*[ -/]*[@-~]|[@-Z\\-_])/g;
+const ZERO_WIDTH_PATTERN = /[\u200B-\u200D\uFEFF]/g;
+const CONTROL_PATTERN = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g;
+const stripInvalidSurrogates = (text) => {
+    let result = "";
+    for (let i = 0; i < text.length; i += 1) {
+        const code = text.charCodeAt(i);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = text.charCodeAt(i + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                result += text[i] + text[i + 1];
+                i += 1;
+            }
+            else {
+                result += "�";
+            }
+            continue;
+        }
+        if (code >= 0xdc00 && code <= 0xdfff) {
+            result += "�";
+            continue;
+        }
+        result += text[i];
+    }
+    return result;
+};
+export const sanitizeText = (text) => {
+    if (!text)
+        return text;
+    return stripInvalidSurrogates(text)
+        .normalize("NFKC")
+        .replace(/\r\n?/g, "\n")
+        .replace(ANSI_PATTERN, "")
+        .replace(ZERO_WIDTH_PATTERN, "")
+        .replace(CONTROL_PATTERN, "");
+};

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

@@ -0,0 +1 @@
+export declare const isDirectMempalaceMutationTool: (tool: string) => boolean;

package/dist/plugin/lib/enforcement.js

@@ -0,0 +1,10 @@
+export const isDirectMempalaceMutationTool = (tool) => {
+    return [
+        "mempalace_add_drawer",
+        "mempalace_kg_add",
+        "mempalace_diary_write",
+        "mcp-router_mempalace_add_drawer",
+        "mcp-router_mempalace_kg_add",
+        "mcp-router_mempalace_diary_write",
+    ].includes(tool);
+};