@rvboris/opencode-mempalace 0.1.0

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

@@ -0,0 +1,11 @@
+type LogLevel = "INFO" | "WARN" | "ERROR";
+export declare const setLogger: (client: {
+    app?: {
+        log?: (input: {
+            body: any;
+        }) => Promise<unknown>;
+    };
+}) => void;
+export declare const resetLogger: () => void;
+export declare const writeLog: (level: LogLevel, message: string, details?: Record<string, unknown>) => Promise<void>;
+export {};

package/dist/plugin/lib/log.js

@@ -0,0 +1,48 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+let logger = async () => { };
+const getFileLogPath = () => {
+    return process.env.MEMPALACE_AUTOSAVE_LOG_FILE || path.join(os.homedir(), ".mempalace", "opencode_autosave.log");
+};
+const writeFileLog = async (level, message, details) => {
+    try {
+        const filePath = getFileLogPath();
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.appendFile(filePath, `${JSON.stringify({ timestamp: new Date().toISOString(), level, message, details })}\n`, "utf8");
+    }
+    catch {
+        // avoid crashing plugin because of file logging
+    }
+};
+const toAppLevel = (level) => {
+    if (level === "WARN")
+        return "warn";
+    if (level === "ERROR")
+        return "error";
+    return "info";
+};
+export const setLogger = (client) => {
+    logger = async (level, message, details) => {
+        await writeFileLog(level, message, details);
+        try {
+            await client.app?.log?.({
+                body: {
+                    service: "mempalace-autosave",
+                    level: toAppLevel(level),
+                    message,
+                    extra: details,
+                },
+            });
+        }
+        catch {
+            // avoid crashing plugin because of logging
+        }
+    };
+};
+export const resetLogger = () => {
+    logger = async () => { };
+};
+export const writeLog = async (level, message, details) => {
+    await logger(level, message, details);
+};

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

@@ -0,0 +1,3 @@
+export declare const stripPrivateContent: (text: string) => string;
+export declare const isFullyPrivate: (text: string) => boolean;
+export declare const redactSecrets: (text: string) => string;

package/dist/plugin/lib/privacy.js

@@ -0,0 +1,19 @@
+import { sanitizeText } from "./derive";
+const PRIVATE_BLOCK_PATTERN = /<private>[\s\S]*?<\/private>/gi;
+const SECRET_PATTERNS = [
+    /sk-[A-Za-z0-9]{20,}/gi,
+    /ghp_[A-Za-z0-9]{20,}/gi,
+    /xox[baprs]-[A-Za-z0-9-]{10,}/gi,
+    /AKIA[0-9A-Z]{16}/gi,
+    /-----BEGIN [A-Z ]+PRIVATE KEY-----/g,
+    /password\s*[:=]\s*\S+/gi,
+    /token\s*[:=]\s*\S+/gi,
+];
+export const stripPrivateContent = (text) => sanitizeText(text.replace(PRIVATE_BLOCK_PATTERN, "[REDACTED_PRIVATE]"));
+export const isFullyPrivate = (text) => {
+    const stripped = text.replace(PRIVATE_BLOCK_PATTERN, "").trim();
+    return stripped.length === 0;
+};
+export const redactSecrets = (text) => {
+    return SECRET_PATTERNS.reduce((current, pattern) => current.replace(pattern, "[REDACTED_SECRET]"), stripPrivateContent(text));
+};

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

@@ -0,0 +1,8 @@
+export declare const getProjectScope: (projectName: string | undefined, projectWingPrefix: string) => {
+    wing: string;
+    rooms: string[];
+};
+export declare const getUserScope: (userWingPrefix: string) => {
+    wing: string;
+    rooms: string[];
+};

package/dist/plugin/lib/scope.js

@@ -0,0 +1,16 @@
+const slugify = (value, fallback) => {
+    const slug = value.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    return slug || fallback;
+};
+export const getProjectScope = (projectName, projectWingPrefix) => {
+    return {
+        wing: `${projectWingPrefix}_${slugify(projectName || "default", "default")}`,
+        rooms: ["architecture", "workflow", "decisions", "bugs", "setup"],
+    };
+};
+export const getUserScope = (userWingPrefix) => {
+    return {
+        wing: `${userWingPrefix}_profile`,
+        rooms: ["preferences", "workflow", "communication"],
+    };
+};

package/dist/plugin/tools/mempalace-memory.d.ts

@@ -0,0 +1,42 @@
+type PluginContext = {
+    project: any;
+    $: any;
+};
+export declare const mempalaceMemoryTool: (ctx: PluginContext) => {
+    description: string;
+    args: {
+        mode: import("zod").ZodEnum<{
+            search: "search";
+            save: "save";
+            kg_add: "kg_add";
+            diary_write: "diary_write";
+        }>;
+        scope: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+            user: "user";
+            project: "project";
+        }>>>;
+        room: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        content: import("zod").ZodOptional<import("zod").ZodString>;
+        query: import("zod").ZodOptional<import("zod").ZodString>;
+        subject: import("zod").ZodOptional<import("zod").ZodString>;
+        predicate: import("zod").ZodOptional<import("zod").ZodString>;
+        object: import("zod").ZodOptional<import("zod").ZodString>;
+        topic: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        agent_name: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+        limit: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    };
+    execute(args: {
+        mode: "search" | "save" | "kg_add" | "diary_write";
+        scope: "user" | "project";
+        room: string;
+        topic: string;
+        agent_name: string;
+        limit: number;
+        content?: string | undefined;
+        query?: string | undefined;
+        subject?: string | undefined;
+        predicate?: string | undefined;
+        object?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export {};

package/dist/plugin/tools/mempalace-memory.js

@@ -0,0 +1,89 @@
+import { tool } from "@opencode-ai/plugin";
+import { executeAdapter } from "../lib/adapter";
+import { loadConfig } from "../lib/config";
+import { sanitizeText } from "../lib/derive";
+import { isFullyPrivate, redactSecrets } from "../lib/privacy";
+import { getProjectScope, getUserScope } from "../lib/scope";
+const getProjectWing = (projectName, prefix) => {
+    return getProjectScope(projectName, prefix).wing;
+};
+const getUserWing = (prefix) => {
+    return getUserScope(prefix).wing;
+};
+const normalizeValue = (value, redact) => {
+    if (value == null)
+        return value;
+    const sanitized = sanitizeText(value);
+    return redact ? redactSecrets(sanitized) : sanitized;
+};
+export const mempalaceMemoryTool = (ctx) => tool({
+    description: "Save or search memory in MemPalace with scope/privacy enforcement",
+    args: {
+        mode: tool.schema.enum(["save", "search", "kg_add", "diary_write"]),
+        scope: tool.schema.enum(["user", "project"]).optional().default("project"),
+        room: tool.schema.string().optional().default("workflow"),
+        content: tool.schema.string().optional(),
+        query: tool.schema.string().optional(),
+        subject: tool.schema.string().optional(),
+        predicate: tool.schema.string().optional(),
+        object: tool.schema.string().optional(),
+        topic: tool.schema.string().optional().default("autosave"),
+        agent_name: tool.schema.string().optional().default("opencode"),
+        limit: tool.schema.number().optional().default(5),
+    },
+    async execute(args) {
+        const config = await loadConfig();
+        const wing = args.scope === "user"
+            ? getUserWing(config.userWingPrefix)
+            : getProjectWing(ctx.project?.name, config.projectWingPrefix);
+        if (args.mode === "save") {
+            if (!args.content)
+                return JSON.stringify({ success: false, error: "content is required" });
+            if (isFullyPrivate(args.content)) {
+                return JSON.stringify({ success: false, error: "content is fully private and will not be saved" });
+            }
+            const content = normalizeValue(args.content, config.privacyRedactionEnabled);
+            const result = await executeAdapter(ctx.$, {
+                mode: "save",
+                wing,
+                room: normalizeValue(args.room, false),
+                content,
+                added_by: "opencode",
+            });
+            return JSON.stringify(result);
+        }
+        if (args.mode === "search") {
+            if (!args.query)
+                return JSON.stringify({ success: false, error: "query is required" });
+            const result = await executeAdapter(ctx.$, {
+                mode: "search",
+                query: normalizeValue(args.query, config.privacyRedactionEnabled),
+                wing,
+                room: normalizeValue(args.room, false),
+                limit: args.limit,
+            });
+            return JSON.stringify(result);
+        }
+        if (args.mode === "kg_add") {
+            if (!args.subject || !args.predicate || !args.object) {
+                return JSON.stringify({ success: false, error: "subject, predicate, and object are required" });
+            }
+            const result = await executeAdapter(ctx.$, {
+                mode: "kg_add",
+                subject: normalizeValue(args.subject, config.privacyRedactionEnabled),
+                predicate: normalizeValue(args.predicate, false),
+                object: normalizeValue(args.object, config.privacyRedactionEnabled),
+                valid_from: new Date().toISOString().slice(0, 10),
+                source_closet: "",
+            });
+            return JSON.stringify(result);
+        }
+        const result = await executeAdapter(ctx.$, {
+            mode: "diary_write",
+            agent_name: normalizeValue(args.agent_name, false),
+            entry: normalizeValue(args.content || "", config.privacyRedactionEnabled),
+            topic: normalizeValue(args.topic, false),
+        });
+        return JSON.stringify(result);
+    },
+});

package/example-opencode.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@rvboris/opencode-mempalace"]
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@rvboris/opencode-mempalace",
+  "version": "0.1.0",
+  "description": "OpenCode plugin for hidden MemPalace retrieval and autosave via a local Python adapter.",
+  "type": "module",
+  "main": "dist/plugin/index.js",
+  "types": "dist/plugin/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/plugin/index.js",
+      "types": "./dist/plugin/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "README.ru.md",
+    "LICENSE",
+    "example-opencode.json"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "mempalace",
+    "memory"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@opencode-ai/plugin": "^1.4.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.4.0",
+    "@types/bun": "^1.3.0",
+    "@types/node": "^22.13.9",
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepublishOnly": "npm run build",
+    "test": "bun test"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}