Saket Aryan
586 lines
20 KiB
TypeScript
586 lines
20 KiB
TypeScript
// Mem0 memory plugin for OpenCode: captures and recalls memories across sessions
|
|
// (add / search / manage) via the Mem0 platform, wired through OpenCode plugin hooks.
|
|
import type { Plugin } from "@opencode-ai/plugin";
|
|
import { MemoryClient } from "mem0ai";
|
|
import { userInfo } from "os";
|
|
import { basename, resolve, dirname } from "path";
|
|
import { randomBytes } from "crypto";
|
|
import { existsSync, readdirSync, cpSync, mkdirSync, readFileSync, writeFileSync } from "fs";
|
|
|
|
async function getUserId(): Promise<string> {
|
|
if (process.env.MEM0_USER_ID) return process.env.MEM0_USER_ID;
|
|
try {
|
|
return userInfo().username;
|
|
} catch {}
|
|
return process.env.USER || process.env.USERNAME || "unknown";
|
|
}
|
|
|
|
async function getProjectId($: any): Promise<string> {
|
|
if (process.env.MEM0_APP_ID) return process.env.MEM0_APP_ID;
|
|
try {
|
|
const r = await $`git remote get-url origin`.quiet();
|
|
const remote = r.stdout.toString().trim();
|
|
const m = remote.match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
|
|
if (m) return m[1].replace("/", "-");
|
|
} catch {}
|
|
return basename(process.cwd());
|
|
}
|
|
|
|
async function getBranch($: any): Promise<string> {
|
|
try {
|
|
const r = await $`git branch --show-current`.quiet();
|
|
return r.stdout.toString().trim() || "main";
|
|
} catch {}
|
|
return "main";
|
|
}
|
|
|
|
function extractMemories(res: any): Array<{ memory: string; id: string }> {
|
|
const arr = res?.results ?? res;
|
|
if (!Array.isArray(arr)) return [];
|
|
return arr.map((m: any) => ({ memory: m.memory ?? "", id: m.id ?? "" }));
|
|
}
|
|
|
|
function generateSessionId(): string {
|
|
const ts = Math.floor(Date.now() / 1000);
|
|
const rnd = randomBytes(3).toString("hex");
|
|
return `ses_${ts}_${rnd}`;
|
|
}
|
|
|
|
const SECRET_PATTERNS = [
|
|
/sk-[A-Za-z0-9]{20,}/g,
|
|
/m0-[A-Za-z0-9]{20,}/g,
|
|
/AKIA[0-9A-Z]{16}/g,
|
|
/xox[baprs]-[A-Za-z0-9-]{20,}/g,
|
|
/ghp_[A-Za-z0-9]{36,}/g,
|
|
/gho_[A-Za-z0-9]{36,}/g,
|
|
];
|
|
|
|
function redact(text: string): string {
|
|
let out = text;
|
|
for (const re of SECRET_PATTERNS) {
|
|
out = out.replace(re, "[REDACTED]");
|
|
}
|
|
return out;
|
|
}
|
|
|
|
const NUDGE_RE =
|
|
/\b(remember\s+(this|that)|memorize|save\s+this|note\s+(this|that)|don'?t\s+forget|always\s+remember|never\s+forget|keep\s+(this|that)\s+in\s+(mind|memory)|store\s+(this|that))\b/i;
|
|
|
|
const RESUME_RE =
|
|
/where\s+(did\s+)?(we|I)\s+(leave|left)\s+off|continue\s+(from\s+)?(where|last)|what\s+were\s+we\s+(working|doing)|pick\s+up\s+where|resume\s+(from\s+|where\s+)|what.s\s+the\s+(current|latest)\s+(state|status)|catch\s+me\s+up|where\s+are\s+we/i;
|
|
|
|
const ERROR_STRONG_RE =
|
|
/Traceback \(most recent call last\)|panic: |FATAL:|error\[E\d+\]/;
|
|
const ERROR_MULTI_RE = /(Error:|Exception:)/g;
|
|
|
|
const MEM0_MCP_RE = /mem0.*(?:add_memory|search_memories|get_memor|delete_memor|update_memory|delete_entities|list_entities)/i;
|
|
const WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "write", "edit", "multiEdit"]);
|
|
|
|
function isMem0Tool(name: string): boolean {
|
|
return MEM0_MCP_RE.test(name);
|
|
}
|
|
|
|
function isMem0AddMemory(name: string): boolean {
|
|
return /mem0.*add_memory/i.test(name);
|
|
}
|
|
|
|
function isMem0SearchOrGet(name: string): boolean {
|
|
return /mem0.*(search_memories|get_memories)/i.test(name);
|
|
}
|
|
|
|
function isMem0DeleteAll(name: string): boolean {
|
|
return /mem0.*delete_all_memories/i.test(name);
|
|
}
|
|
|
|
function extractUserText(input: any, output: any): string {
|
|
const parts: any[] = output?.parts;
|
|
if (Array.isArray(parts)) {
|
|
return parts
|
|
.filter((p: any) => p.type === "text" && !p.synthetic)
|
|
.map((p: any) => p.text ?? "")
|
|
.join("\n");
|
|
}
|
|
const msg = output?.message ?? input?.message;
|
|
if (typeof msg?.content === "string") return msg.content;
|
|
if (typeof msg?.text === "string") return msg.text;
|
|
return "";
|
|
}
|
|
|
|
function installSkills(projectDir: string): void {
|
|
const pluginDir = dirname(dirname(import.meta.filename));
|
|
const srcSkills = resolve(pluginDir, "opencode-skills");
|
|
if (!existsSync(srcSkills)) return;
|
|
|
|
const destSkills = resolve(projectDir, ".opencode", "skills");
|
|
const destCommands = resolve(projectDir, ".opencode", "commands");
|
|
try {
|
|
const skills = readdirSync(srcSkills, { withFileTypes: true });
|
|
for (const entry of skills) {
|
|
if (!entry.isDirectory()) continue;
|
|
const dest = resolve(destSkills, `mem0-${entry.name}`);
|
|
if (existsSync(dest)) continue;
|
|
cpSync(resolve(srcSkills, entry.name), dest, { recursive: true });
|
|
}
|
|
|
|
for (const entry of skills) {
|
|
if (!entry.isDirectory()) continue;
|
|
const cmdFile = resolve(destCommands, `mem0-${entry.name}.md`);
|
|
if (existsSync(cmdFile)) continue;
|
|
const skillMd = resolve(srcSkills, entry.name, "SKILL.md");
|
|
if (!existsSync(skillMd)) continue;
|
|
let desc = "Mem0 " + entry.name + " skill";
|
|
try {
|
|
const content = readFileSync(skillMd, "utf8");
|
|
const m = content.match(/^description:\s*(.+)$/m);
|
|
if (m) desc = m[1].trim();
|
|
} catch {}
|
|
const cmdContent = `---\ndescription: ${desc}\n---\nLoad and follow the skill at .opencode/skills/mem0-${entry.name}/SKILL.md\n\nUse the mem0 MCP tools (search_memories, get_memories, add_memory, delete_memory, update_memory, list_entities, delete_entities, get_event_status) to execute the skill instructions.\n\nIdentity context (from environment):\n- user_id: Use MEM0_USER_ID env var, or fall back to $USER\n- app_id: Use MEM0_APP_ID env var\n- session_id: Use MEM0_SESSION_ID env var\n- branch: Use MEM0_BRANCH env var\n`;
|
|
try {
|
|
mkdirSync(destCommands, { recursive: true });
|
|
writeFileSync(cmdFile, cmdContent, "utf8");
|
|
} catch {}
|
|
}
|
|
} catch {}
|
|
}
|
|
|
|
const Mem0Plugin: Plugin = async (ctx) => {
|
|
const { $, client } = ctx;
|
|
|
|
try {
|
|
const projectDir = (ctx as any).directory ?? process.cwd();
|
|
installSkills(projectDir);
|
|
} catch {}
|
|
|
|
const apiKey = process.env.MEM0_API_KEY;
|
|
|
|
if (!apiKey) {
|
|
try {
|
|
await client.app.log({
|
|
body: {
|
|
service: "mem0",
|
|
level: "warn",
|
|
message:
|
|
"MEM0_API_KEY not set. Get one at https://app.mem0.ai/dashboard/api-keys",
|
|
},
|
|
});
|
|
} catch {}
|
|
return {};
|
|
}
|
|
|
|
const mem0 = new MemoryClient({ apiKey });
|
|
const userId = await getUserId();
|
|
const appId = await getProjectId($);
|
|
const branch = await getBranch($);
|
|
const stats = { adds: 0, searches: 0, messages: 0 };
|
|
const sessionId = generateSessionId();
|
|
|
|
let initialized = false;
|
|
let memoryCount = 0;
|
|
let msgCount = 0;
|
|
|
|
const systemContext: string[] = [];
|
|
|
|
return {
|
|
"chat.message": async (input: any, output: any) => {
|
|
const userText = extractUserText(input, output);
|
|
if (!userText || userText.length < 10) return;
|
|
|
|
const safeText = redact(userText);
|
|
msgCount++;
|
|
stats.messages++;
|
|
|
|
if (!initialized) {
|
|
initialized = true;
|
|
|
|
try {
|
|
const all = await mem0.getAll({
|
|
filters: {
|
|
AND: [{ user_id: userId }, { app_id: appId }],
|
|
},
|
|
page: 1,
|
|
pageSize: 1,
|
|
});
|
|
memoryCount =
|
|
(all as any)?.count ??
|
|
(all as any)?.results?.length ??
|
|
0;
|
|
|
|
systemContext.push(
|
|
`Always include user_id="${userId}" and app_id="${appId}" in every search_memories filter and add_memory call.`,
|
|
);
|
|
|
|
if (memoryCount === 0) {
|
|
systemContext.push(
|
|
"New project with 0 memories. Suggest running /mem0:onboard to import project files and install coding categories.",
|
|
);
|
|
}
|
|
|
|
if (memoryCount > 0) {
|
|
systemContext.push(
|
|
"Search mem0 for recent decisions and task learnings before responding. Run 2 parallel searches: one for decision type, one for task_learning type.",
|
|
);
|
|
try {
|
|
const res = await mem0.search(
|
|
"recent session state decisions and learnings",
|
|
{
|
|
filters: {
|
|
AND: [{ user_id: userId }, { app_id: appId }],
|
|
},
|
|
topK: 5,
|
|
},
|
|
);
|
|
stats.searches++;
|
|
const memories = extractMemories(res);
|
|
if (memories.length > 0) {
|
|
const memLines = memories
|
|
.map((m) => `- ${m.memory}`)
|
|
.join("\n");
|
|
systemContext.push(`Prior context from mem0:\n${memLines}`);
|
|
}
|
|
} catch {}
|
|
}
|
|
|
|
systemContext.push(
|
|
"Mem0 searches apply when user references past work, decision questions, errors, or non-trivial tasks. Queries use noun-phrases, 2-4 parallel calls with different metadata.type filters, and include user_id + app_id.",
|
|
);
|
|
} catch (err: any) {
|
|
try {
|
|
await client.app.log({
|
|
body: {
|
|
service: "mem0",
|
|
level: "error",
|
|
message: `Session init error: ${err?.message}`,
|
|
},
|
|
});
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
if (NUDGE_RE.test(safeText)) {
|
|
systemContext.push(
|
|
"[MEMORY TRIGGER] User asked to remember something. Call add_memory with the user's statement, confidence=1.0, infer=false.",
|
|
);
|
|
}
|
|
|
|
const hasResume = RESUME_RE.test(safeText);
|
|
if (hasResume) {
|
|
try {
|
|
const [stateRes, decisionsRes] = await Promise.all([
|
|
mem0.search("session state current task", {
|
|
filters: {
|
|
AND: [
|
|
{ user_id: userId },
|
|
{ app_id: appId },
|
|
{ metadata: { type: "session_state" } },
|
|
],
|
|
},
|
|
topK: 3,
|
|
}),
|
|
mem0.search("recent decisions and learnings", {
|
|
filters: {
|
|
AND: [
|
|
{ user_id: userId },
|
|
{ app_id: appId },
|
|
{ metadata: { type: "decision" } },
|
|
],
|
|
},
|
|
topK: 3,
|
|
}),
|
|
]);
|
|
stats.searches += 2;
|
|
const all = [
|
|
...extractMemories(stateRes),
|
|
...extractMemories(decisionsRes),
|
|
];
|
|
const seen = new Set<string>();
|
|
const unique = all.filter((m) => {
|
|
if (seen.has(m.id)) return false;
|
|
seen.add(m.id);
|
|
return true;
|
|
});
|
|
if (unique.length > 0) {
|
|
const memLines = unique.map((m) => `- ${m.memory}`).join("\n");
|
|
systemContext.push(
|
|
`Session resume context:\n${memLines}\n\nThese memories provide context for resuming work.`,
|
|
);
|
|
}
|
|
} catch {}
|
|
}
|
|
|
|
if (!hasResume && memoryCount > 0) {
|
|
try {
|
|
const res = await mem0.search(safeText, {
|
|
filters: { AND: [{ user_id: userId }, { app_id: appId }] },
|
|
topK: 5,
|
|
});
|
|
stats.searches++;
|
|
const memories = extractMemories(res);
|
|
if (memories.length > 0) {
|
|
const memLines = memories.map((m) => `- ${m.memory}`).join("\n");
|
|
systemContext.push(`Relevant memories:\n${memLines}`);
|
|
}
|
|
} catch {}
|
|
}
|
|
|
|
if (msgCount % 3 === 0) {
|
|
Promise.resolve().then(async () => {
|
|
try {
|
|
await mem0.add([{ role: "user", content: safeText }], {
|
|
user_id: userId,
|
|
app_id: appId,
|
|
metadata: {
|
|
type: "auto_capture",
|
|
source: "opencode",
|
|
confidence: 0.7,
|
|
session_id: sessionId,
|
|
branch,
|
|
},
|
|
infer: true,
|
|
} as any);
|
|
stats.adds++;
|
|
} catch {}
|
|
});
|
|
}
|
|
|
|
if (msgCount % 5 === 0 && stats.adds < Math.floor(msgCount / 3)) {
|
|
systemContext.push(
|
|
"After responding, store any new decisions, learnings, or preferences from this exchange via add_memory. Keep it to 1 sentence per memory.",
|
|
);
|
|
}
|
|
},
|
|
|
|
"experimental.chat.messages.transform": async (
|
|
_input: any,
|
|
output: { messages: { info: any; parts: any[] }[] },
|
|
) => {
|
|
if (systemContext.length === 0 || !output?.messages?.length) return;
|
|
|
|
const firstUser = output.messages.find(
|
|
(m) => m.info.role === "user",
|
|
);
|
|
if (!firstUser || !firstUser.parts.length) return;
|
|
|
|
const marker = "## Mem0 Memory Context";
|
|
if (firstUser.parts.some((p: any) => p.type === "text" && p.text?.includes(marker))) return;
|
|
|
|
const block = `${marker}\n\n${systemContext.join("\n\n")}`;
|
|
const ref = firstUser.parts[0];
|
|
firstUser.parts.unshift({ ...ref, type: "text", text: block });
|
|
},
|
|
|
|
"tool.execute.before": async (input: any, output: any) => {
|
|
const toolName: string = input?.tool ?? "";
|
|
|
|
if (WRITE_TOOLS.has(toolName)) {
|
|
const fp = String(
|
|
output?.args?.file_path ?? output?.args?.filePath ?? "",
|
|
);
|
|
if (/MEMORY\.md|\.claude\/memory/i.test(fp)) {
|
|
throw new Error(
|
|
"Use the add_memory MCP tool instead of writing to MEMORY.md",
|
|
);
|
|
}
|
|
}
|
|
|
|
if (isMem0Tool(toolName) && output?.args) {
|
|
if (!output.args.user_id) output.args.user_id = userId;
|
|
if (!output.args.app_id) output.args.app_id = appId;
|
|
|
|
if (isMem0AddMemory(toolName)) {
|
|
if (!output.args.metadata) output.args.metadata = {};
|
|
const meta = output.args.metadata;
|
|
if (meta.confidence === undefined) meta.confidence = 0.7;
|
|
if (!meta.source) meta.source = "opencode";
|
|
if (!meta.type) meta.type = "task_learning";
|
|
if (!meta.session_id) meta.session_id = sessionId;
|
|
if (!meta.files) meta.files = ["*"];
|
|
if (!meta.branch) meta.branch = branch;
|
|
if (meta.confidence >= 1.0 && output.args.infer === undefined) {
|
|
output.args.infer = false;
|
|
}
|
|
}
|
|
|
|
if (isMem0SearchOrGet(toolName)) {
|
|
const existingFilters = output.args.filters;
|
|
if (existingFilters === undefined || existingFilters === null) {
|
|
output.args.filters = {
|
|
AND: [{ user_id: userId }, { app_id: appId }],
|
|
};
|
|
} else if (typeof existingFilters === "object") {
|
|
const andClauses: any[] = existingFilters.AND;
|
|
if (Array.isArray(andClauses)) {
|
|
const hasUid = andClauses.some(
|
|
(c: any) => c && typeof c === "object" && "user_id" in c,
|
|
);
|
|
const hasAid = andClauses.some(
|
|
(c: any) => c && typeof c === "object" && "app_id" in c,
|
|
);
|
|
if (!hasUid) andClauses.push({ user_id: userId });
|
|
if (!hasAid) andClauses.push({ app_id: appId });
|
|
} else if (andClauses === undefined) {
|
|
const hasUid = "user_id" in existingFilters;
|
|
const hasAid = "app_id" in existingFilters;
|
|
if (!hasUid || !hasAid) {
|
|
const existing = Object.entries(existingFilters).map(
|
|
([k, v]) => ({ [k]: v }),
|
|
);
|
|
if (!hasUid) existing.push({ user_id: userId });
|
|
if (!hasAid) existing.push({ app_id: appId });
|
|
output.args.filters = { AND: existing };
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isMem0DeleteAll(toolName)) {
|
|
if (!output.args.user_id) output.args.user_id = userId;
|
|
if (!output.args.app_id) output.args.app_id = appId;
|
|
}
|
|
|
|
if (!isMem0AddMemory(toolName) && !output.args.metadata) {
|
|
output.args.metadata = { source: "opencode", branch };
|
|
}
|
|
}
|
|
},
|
|
|
|
"tool.execute.after": async (input: any, _output: any) => {
|
|
const toolName: string = input?.tool ?? "";
|
|
const toolOutput: string = input?.output ?? _output?.output ?? "";
|
|
|
|
if (MEM0_MCP_RE.test(toolName)) {
|
|
if (toolName.includes("add_memory")) stats.adds++;
|
|
if (toolName.includes("search")) stats.searches++;
|
|
}
|
|
|
|
if (toolName === "bash" && toolOutput.length >= 50) {
|
|
const command: string = input?.args?.command ?? "";
|
|
if (/git\s+(commit|merge|rebase)/.test(command)) return;
|
|
|
|
const hasStrongError = ERROR_STRONG_RE.test(toolOutput);
|
|
const multiErrors = (toolOutput.match(ERROR_MULTI_RE) ?? []).length;
|
|
if (!hasStrongError && multiErrors < 2) return;
|
|
|
|
try {
|
|
const errorLine =
|
|
toolOutput
|
|
.split("\n")
|
|
.find((l: string) =>
|
|
/Error:|Exception:|panic:|FAIL:|fatal:/i.test(l),
|
|
)
|
|
?.replace(/^\s+/, "")
|
|
.slice(0, 120) ?? "";
|
|
|
|
const traceFiles = [
|
|
...new Set(
|
|
toolOutput.match(
|
|
/[a-zA-Z0-9_./-]+\.(py|ts|tsx|js|jsx|rs|go|rb|java|sh)(:\d+)?/g,
|
|
) ?? [],
|
|
),
|
|
].slice(0, 5);
|
|
|
|
const errorQuery = errorLine.slice(0, 80);
|
|
if (errorQuery.length < 10) return;
|
|
|
|
const [antiPatternRes, bugFixRes] = await Promise.all([
|
|
mem0.search(`error: ${errorQuery}`, {
|
|
filters: {
|
|
AND: [
|
|
{ user_id: userId },
|
|
{ app_id: appId },
|
|
{ metadata: { type: "anti_pattern" } },
|
|
],
|
|
},
|
|
topK: 3,
|
|
}),
|
|
mem0.search(`error: ${errorQuery}`, {
|
|
filters: {
|
|
AND: [
|
|
{ user_id: userId },
|
|
{ app_id: appId },
|
|
{ metadata: { type: "bug_fix" } },
|
|
],
|
|
},
|
|
topK: 3,
|
|
}),
|
|
]);
|
|
stats.searches += 2;
|
|
|
|
const allResults = [
|
|
...extractMemories(antiPatternRes),
|
|
...extractMemories(bugFixRes),
|
|
];
|
|
const seen = new Set<string>();
|
|
const unique = allResults.filter((m) => {
|
|
if (seen.has(m.id)) return false;
|
|
seen.add(m.id);
|
|
return true;
|
|
});
|
|
|
|
let ctx = `Error detected: \`${command.slice(0, 100)}\` produced:\n> ${errorLine}`;
|
|
if (traceFiles.length > 0) {
|
|
ctx += `\nFiles in stack trace: ${traceFiles.join(", ")}`;
|
|
}
|
|
if (unique.length > 0) {
|
|
const lines = unique.map((m) => `- ${m.memory}`).join("\n");
|
|
ctx += `\nPrior error memories:\n${lines}`;
|
|
}
|
|
ctx +=
|
|
"\nStore resolved errors as anti_pattern or bug_fix memories for future reference.";
|
|
systemContext.push(ctx);
|
|
} catch {}
|
|
}
|
|
},
|
|
|
|
"experimental.session.compacting": async (
|
|
input: { sessionID?: string },
|
|
output: { context: string[]; prompt?: string },
|
|
) => {
|
|
try {
|
|
const compactSessionId = input?.sessionID ?? sessionId;
|
|
const summaryContent = `Session compacting. Project: ${appId}. Branch: ${branch}. Session: ${compactSessionId}. Stats: ${stats.adds} memories stored, ${stats.searches} searches, ${stats.messages} messages.`;
|
|
Promise.resolve().then(async () => {
|
|
try {
|
|
await mem0.add([{ role: "user", content: summaryContent }], {
|
|
user_id: userId,
|
|
app_id: appId,
|
|
metadata: {
|
|
type: "session_state",
|
|
source: "pre-compaction",
|
|
session_id: compactSessionId,
|
|
branch,
|
|
},
|
|
infer: true,
|
|
} as any);
|
|
} catch {}
|
|
});
|
|
|
|
const res = await mem0.search("session state decisions learnings", {
|
|
filters: { AND: [{ user_id: userId }, { app_id: appId }] },
|
|
topK: 10,
|
|
});
|
|
const memories = extractMemories(res);
|
|
if (memories.length > 0 && output?.context) {
|
|
const lines = memories.map((m) => `- ${m.memory}`).join("\n");
|
|
output.context.push(
|
|
`## Mem0 Memories (preserve across compaction)\n\n${lines}\n\nIMPORTANT: After compaction, store any key decisions or learnings using the add_memory MCP tool.`,
|
|
);
|
|
}
|
|
} catch {}
|
|
},
|
|
|
|
"shell.env": async (
|
|
_input: { cwd: string; sessionID?: string },
|
|
output: { env: Record<string, string> },
|
|
) => {
|
|
if (output?.env) {
|
|
output.env.MEM0_USER_ID = userId;
|
|
output.env.MEM0_APP_ID = appId;
|
|
output.env.MEM0_SESSION_ID = sessionId;
|
|
output.env.MEM0_BRANCH = branch;
|
|
}
|
|
},
|
|
};
|
|
};
|
|
|
|
export default Mem0Plugin;
|