|
|
|
@@ -0,0 +1,493 @@
|
|
|
|
|
/**
|
|
|
|
|
* MC Plugin — registers /mc as a native slash command in OpenClaw gateway.
|
|
|
|
|
* Provides interactive commands for the Memory Continuity plugin.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
import fs from "node:fs";
|
|
|
|
|
import path from "node:path";
|
|
|
|
|
|
|
|
|
|
// ── Helpers ─────────────────────────────────────────────────────────────
|
|
|
|
|
|
|
|
|
|
function mono(text) { return "```\n" + text + "\n```"; }
|
|
|
|
|
|
|
|
|
|
const BASE = process.env.OPENCLAW_HOME || path.join(process.env.HOME || "/tmp", ".openclaw");
|
|
|
|
|
const MAIN_WS = path.join(BASE, "workspace", "main", "memory");
|
|
|
|
|
const EXTRA_WS = path.join(BASE, "workspaces");
|
|
|
|
|
|
|
|
|
|
/** Discover all agent workspaces that have memory directories */
|
|
|
|
|
function discoverAgents() {
|
|
|
|
|
const agents = [];
|
|
|
|
|
|
|
|
|
|
// Main workspace
|
|
|
|
|
if (fs.existsSync(path.join(MAIN_WS, "CURRENT_STATE.md"))) {
|
|
|
|
|
agents.push({ name: "main", memDir: MAIN_WS });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Sub-agent workspaces
|
|
|
|
|
try {
|
|
|
|
|
for (const d of fs.readdirSync(EXTRA_WS)) {
|
|
|
|
|
const memDir = path.join(EXTRA_WS, d, "memory");
|
|
|
|
|
if (fs.existsSync(path.join(memDir, "CURRENT_STATE.md"))) {
|
|
|
|
|
agents.push({ name: d, memDir });
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} catch {}
|
|
|
|
|
|
|
|
|
|
return agents;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function resolveMemDir(agentName) {
|
|
|
|
|
if (!agentName || agentName === "main") return MAIN_WS;
|
|
|
|
|
const p = path.join(EXTRA_WS, agentName, "memory");
|
|
|
|
|
return fs.existsSync(p) ? p : null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function readFile(fp) {
|
|
|
|
|
try { return fs.readFileSync(fp, "utf8"); } catch { return null; }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function extractSection(md, heading) {
|
|
|
|
|
const re = new RegExp(`^##\\s+${heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`, "m");
|
|
|
|
|
return (md.match(re)?.[1] ?? "").trim();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function relTime(dateStr) {
|
|
|
|
|
try {
|
|
|
|
|
const diff = Date.now() - new Date(dateStr).getTime();
|
|
|
|
|
const mins = Math.floor(diff / 60000);
|
|
|
|
|
if (mins < 1) return "just now";
|
|
|
|
|
if (mins < 60) return `${mins}m ago`;
|
|
|
|
|
const hrs = Math.floor(mins / 60);
|
|
|
|
|
if (hrs < 24) return `${hrs}h ${mins % 60}m ago`;
|
|
|
|
|
return `${Math.floor(hrs / 24)}d ago`;
|
|
|
|
|
} catch { return dateStr || "unknown"; }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function truncate(s, max = 120) {
|
|
|
|
|
if (!s) return "(empty)";
|
|
|
|
|
const line = s.split("\n")[0];
|
|
|
|
|
return line.length > max ? line.slice(0, max) + "…" : line;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ── Subcommand handlers ─────────────────────────────────────────────────
|
|
|
|
|
|
|
|
|
|
function cmdState(args) {
|
|
|
|
|
const agent = args || "main";
|
|
|
|
|
const memDir = resolveMemDir(agent);
|
|
|
|
|
if (!memDir) return `Agent "${agent}" not found.`;
|
|
|
|
|
|
|
|
|
|
const md = readFile(path.join(memDir, "CURRENT_STATE.md"));
|
|
|
|
|
if (!md) return `No state file for "${agent}".`;
|
|
|
|
|
|
|
|
|
|
const updated = md.match(/^> Last updated:\s*(.+)$/m)?.[1]?.trim();
|
|
|
|
|
|
|
|
|
|
let out = `State: ${agent}\n`;
|
|
|
|
|
out += `Updated: ${relTime(updated)}\n`;
|
|
|
|
|
out += "─────────────────────────────\n";
|
|
|
|
|
for (const section of ["Objective", "Current Step", "Key Decisions", "Next Action", "Blockers"]) {
|
|
|
|
|
const val = extractSection(md, section);
|
|
|
|
|
// Compact multi-line values
|
|
|
|
|
const compact = val.split("\n").slice(0, 3).join("\n");
|
|
|
|
|
out += `${section}:\n ${compact || "(empty)"}\n\n`;
|
|
|
|
|
}
|
|
|
|
|
return out.trimEnd();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmdStateAll() {
|
|
|
|
|
const agents = discoverAgents();
|
|
|
|
|
if (!agents.length) return "No agents with memory found.";
|
|
|
|
|
|
|
|
|
|
let out = `Memory States (${agents.length} agents)\n`;
|
|
|
|
|
out += "─────────────────────────────\n";
|
|
|
|
|
|
|
|
|
|
for (const { name, memDir } of agents) {
|
|
|
|
|
const md = readFile(path.join(memDir, "CURRENT_STATE.md"));
|
|
|
|
|
if (!md) { out += `${name.padEnd(20)} (no state)\n`; continue; }
|
|
|
|
|
|
|
|
|
|
const updated = md.match(/^> Last updated:\s*(.+)$/m)?.[1]?.trim();
|
|
|
|
|
const objective = extractSection(md, "Objective");
|
|
|
|
|
|
|
|
|
|
out += `${name.padEnd(20)} ${relTime(updated).padEnd(10)} ${truncate(objective, 50)}\n`;
|
|
|
|
|
}
|
|
|
|
|
return out.trimEnd();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmdHistory(args) {
|
|
|
|
|
const agent = args || "main";
|
|
|
|
|
const memDir = resolveMemDir(agent);
|
|
|
|
|
if (!memDir) return `Agent "${agent}" not found.`;
|
|
|
|
|
|
|
|
|
|
const archiveDir = path.join(memDir, "session_archive");
|
|
|
|
|
let files;
|
|
|
|
|
try { files = fs.readdirSync(archiveDir).filter(f => f.endsWith(".md")).sort().reverse(); }
|
|
|
|
|
catch { return `No archive for "${agent}".`; }
|
|
|
|
|
|
|
|
|
|
if (!files.length) return `No archived sessions for "${agent}".`;
|
|
|
|
|
|
|
|
|
|
let out = `Session Archive: ${agent} (${files.length} entries)\n`;
|
|
|
|
|
out += "─────────────────────────────\n";
|
|
|
|
|
out += `${"#".padStart(3)} ${"Timestamp".padEnd(20)} Objective\n`;
|
|
|
|
|
out += "─".repeat(60) + "\n";
|
|
|
|
|
|
|
|
|
|
for (let i = 0; i < Math.min(files.length, 20); i++) {
|
|
|
|
|
const f = files[i];
|
|
|
|
|
const ts = f.replace(".md", "").replace(/_/g, " ");
|
|
|
|
|
const md = readFile(path.join(archiveDir, f));
|
|
|
|
|
const obj = md ? truncate(extractSection(md, "Objective"), 35) : "?";
|
|
|
|
|
out += `${String(i + 1).padStart(3)} ${ts.padEnd(20)} ${obj}\n`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (files.length > 20) out += `\n ... and ${files.length - 20} more`;
|
|
|
|
|
return out.trimEnd();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmdRestore(args) {
|
|
|
|
|
const parts = (args || "").trim().split(/\s+/);
|
|
|
|
|
const idx = parseInt(parts[0]);
|
|
|
|
|
const agent = parts[1] || "main";
|
|
|
|
|
|
|
|
|
|
if (isNaN(idx) || idx < 1) return "Usage: /mc restore <N> [agent]\nN = archive number from /mc history";
|
|
|
|
|
|
|
|
|
|
const memDir = resolveMemDir(agent);
|
|
|
|
|
if (!memDir) return `Agent "${agent}" not found.`;
|
|
|
|
|
|
|
|
|
|
const archiveDir = path.join(memDir, "session_archive");
|
|
|
|
|
let files;
|
|
|
|
|
try { files = fs.readdirSync(archiveDir).filter(f => f.endsWith(".md")).sort().reverse(); }
|
|
|
|
|
catch { return `No archive for "${agent}".`; }
|
|
|
|
|
|
|
|
|
|
if (idx > files.length) return `Only ${files.length} archives available.`;
|
|
|
|
|
|
|
|
|
|
const target = files[idx - 1];
|
|
|
|
|
const content = readFile(path.join(archiveDir, target));
|
|
|
|
|
if (!content) return `Failed to read archive ${target}.`;
|
|
|
|
|
|
|
|
|
|
// Backup current state first
|
|
|
|
|
const statePath = path.join(memDir, "CURRENT_STATE.md");
|
|
|
|
|
const current = readFile(statePath);
|
|
|
|
|
if (current) {
|
|
|
|
|
const bak = path.join(memDir, "CURRENT_STATE.md.bak");
|
|
|
|
|
fs.writeFileSync(bak, current, "utf8");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fs.writeFileSync(statePath, content, "utf8");
|
|
|
|
|
return `✓ Restored archive #${idx} (${target.replace(".md", "")})\n Previous state backed up to CURRENT_STATE.md.bak`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmdClear(args) {
|
|
|
|
|
const agent = args || "main";
|
|
|
|
|
const memDir = resolveMemDir(agent);
|
|
|
|
|
if (!memDir) return `Agent "${agent}" not found.`;
|
|
|
|
|
|
|
|
|
|
const statePath = path.join(memDir, "CURRENT_STATE.md");
|
|
|
|
|
const current = readFile(statePath);
|
|
|
|
|
|
|
|
|
|
if (current) {
|
|
|
|
|
// Archive before clearing
|
|
|
|
|
const archiveDir = path.join(memDir, "session_archive");
|
|
|
|
|
fs.mkdirSync(archiveDir, { recursive: true });
|
|
|
|
|
const now = new Date();
|
|
|
|
|
const pad = (n) => String(n).padStart(2, "0");
|
|
|
|
|
const stamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}-${pad(now.getMinutes())}`;
|
|
|
|
|
fs.writeFileSync(path.join(archiveDir, `${stamp}.md`), current, "utf8");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const template = `# Current State
|
|
|
|
|
> Last updated: ${new Date().toISOString()}
|
|
|
|
|
|
|
|
|
|
## Objective
|
|
|
|
|
None
|
|
|
|
|
|
|
|
|
|
## Current Step
|
|
|
|
|
None
|
|
|
|
|
|
|
|
|
|
## Key Decisions
|
|
|
|
|
- None
|
|
|
|
|
|
|
|
|
|
## Next Action
|
|
|
|
|
None
|
|
|
|
|
|
|
|
|
|
## Blockers
|
|
|
|
|
None
|
|
|
|
|
|
|
|
|
|
## Unsurfaced Results
|
|
|
|
|
None
|
|
|
|
|
`;
|
|
|
|
|
fs.writeFileSync(statePath, template, "utf8");
|
|
|
|
|
return `✓ State cleared for "${agent}"\n Previous state archived.`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmdSearch(args) {
|
|
|
|
|
if (!args) return "Usage: /mc search <keyword> [agent]\nSearches current state + archives.";
|
|
|
|
|
|
|
|
|
|
const parts = args.trim().split(/\s+/);
|
|
|
|
|
// Last part might be an agent name
|
|
|
|
|
let keyword, agent;
|
|
|
|
|
const agents = discoverAgents();
|
|
|
|
|
const agentNames = new Set(agents.map(a => a.name));
|
|
|
|
|
|
|
|
|
|
if (parts.length > 1 && agentNames.has(parts[parts.length - 1])) {
|
|
|
|
|
agent = parts.pop();
|
|
|
|
|
keyword = parts.join(" ");
|
|
|
|
|
} else {
|
|
|
|
|
keyword = parts.join(" ");
|
|
|
|
|
agent = null; // search all
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const re = new RegExp(keyword, "gi");
|
|
|
|
|
const results = [];
|
|
|
|
|
|
|
|
|
|
const searchAgents = agent ? [{ name: agent, memDir: resolveMemDir(agent) }] : agents;
|
|
|
|
|
|
|
|
|
|
for (const { name, memDir } of searchAgents) {
|
|
|
|
|
if (!memDir) continue;
|
|
|
|
|
|
|
|
|
|
// Search current state
|
|
|
|
|
const state = readFile(path.join(memDir, "CURRENT_STATE.md"));
|
|
|
|
|
if (state && re.test(state)) {
|
|
|
|
|
const lines = state.split("\n").filter(l => re.test(l));
|
|
|
|
|
results.push({ agent: name, source: "CURRENT_STATE", matches: lines.slice(0, 3) });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Search archives
|
|
|
|
|
const archiveDir = path.join(memDir, "session_archive");
|
|
|
|
|
try {
|
|
|
|
|
const files = fs.readdirSync(archiveDir).filter(f => f.endsWith(".md")).sort().reverse();
|
|
|
|
|
for (const f of files.slice(0, 30)) {
|
|
|
|
|
const content = readFile(path.join(archiveDir, f));
|
|
|
|
|
if (content && re.test(content)) {
|
|
|
|
|
const lines = content.split("\n").filter(l => re.test(l));
|
|
|
|
|
results.push({ agent: name, source: f.replace(".md", ""), matches: lines.slice(0, 2) });
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} catch {}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!results.length) return `No matches for "${keyword}".`;
|
|
|
|
|
|
|
|
|
|
let out = `Search: "${keyword}" (${results.length} hits)\n`;
|
|
|
|
|
out += "─────────────────────────────\n";
|
|
|
|
|
for (const r of results.slice(0, 15)) {
|
|
|
|
|
out += `[${r.agent}] ${r.source}\n`;
|
|
|
|
|
for (const line of r.matches) {
|
|
|
|
|
out += ` ${truncate(line.trim(), 80)}\n`;
|
|
|
|
|
}
|
|
|
|
|
out += "\n";
|
|
|
|
|
}
|
|
|
|
|
if (results.length > 15) out += ` ... and ${results.length - 15} more hits`;
|
|
|
|
|
return out.trimEnd();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmdSettings(args) {
|
|
|
|
|
// Read memory-continuity config from openclaw.json
|
|
|
|
|
const configPath = path.join(BASE, "openclaw.json");
|
|
|
|
|
const raw = readFile(configPath);
|
|
|
|
|
if (!raw) return "Cannot read openclaw.json";
|
|
|
|
|
|
|
|
|
|
let config;
|
|
|
|
|
try { config = JSON.parse(raw); } catch { return "Cannot parse openclaw.json"; }
|
|
|
|
|
|
|
|
|
|
const mcConfig = config?.plugins?.entries?.["memory-continuity"]?.config
|
|
|
|
|
|| config?.entries?.["memory-continuity"]?.config
|
|
|
|
|
|| {};
|
|
|
|
|
|
|
|
|
|
if (!args) {
|
|
|
|
|
const defaults = {
|
|
|
|
|
maxStateLines: { value: mcConfig.maxStateLines ?? 50, desc: "Max lines before compress warning" },
|
|
|
|
|
archiveOnNew: { value: mcConfig.archiveOnNew ?? true, desc: "Archive state on /new" },
|
|
|
|
|
autoExtract: { value: mcConfig.autoExtract ?? true, desc: "Auto-extract state at agent_end" },
|
|
|
|
|
maxArchiveCount: { value: mcConfig.maxArchiveCount ?? 20, desc: "Max archive files kept" },
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let out = "MC Settings\n─────────────────────────────\n";
|
|
|
|
|
for (const [k, v] of Object.entries(defaults)) {
|
|
|
|
|
out += `${k.padEnd(18)} ${String(v.value).padStart(6)} ${v.desc}\n`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Show stats
|
|
|
|
|
const agents = discoverAgents();
|
|
|
|
|
out += "\nStats:\n";
|
|
|
|
|
out += ` Agents with memory: ${agents.length}\n`;
|
|
|
|
|
let totalArchives = 0;
|
|
|
|
|
for (const { memDir } of agents) {
|
|
|
|
|
try {
|
|
|
|
|
totalArchives += fs.readdirSync(path.join(memDir, "session_archive")).filter(f => f.endsWith(".md")).length;
|
|
|
|
|
} catch {}
|
|
|
|
|
}
|
|
|
|
|
out += ` Total archives: ${totalArchives}\n`;
|
|
|
|
|
return out.trimEnd();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Parse "key value" for settings update
|
|
|
|
|
const parts = args.trim().split(/\s+/);
|
|
|
|
|
if (parts.length < 2 || parts[0] === "--help" || parts[0] === "-h") {
|
|
|
|
|
return "Usage: /mc settings <key> <value>\nKeys: maxStateLines, archiveOnNew, autoExtract, maxArchiveCount";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const [key, val] = parts;
|
|
|
|
|
const validKeys = ["maxStateLines", "archiveOnNew", "autoExtract", "maxArchiveCount"];
|
|
|
|
|
if (!validKeys.includes(key)) return `Unknown key: ${key}\nValid: ${validKeys.join(", ")}`;
|
|
|
|
|
|
|
|
|
|
let parsed;
|
|
|
|
|
if (val === "true") parsed = true;
|
|
|
|
|
else if (val === "false") parsed = false;
|
|
|
|
|
else if (!isNaN(Number(val))) parsed = Number(val);
|
|
|
|
|
else return `Cannot parse value: ${val}`;
|
|
|
|
|
|
|
|
|
|
// Update openclaw.json
|
|
|
|
|
try {
|
|
|
|
|
// Ensure path exists
|
|
|
|
|
if (!config.entries) config.entries = {};
|
|
|
|
|
if (!config.entries["memory-continuity"]) config.entries["memory-continuity"] = { enabled: true };
|
|
|
|
|
if (!config.entries["memory-continuity"].config) config.entries["memory-continuity"].config = {};
|
|
|
|
|
config.entries["memory-continuity"].config[key] = parsed;
|
|
|
|
|
fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
|
|
|
|
|
return `✓ ${key} = ${parsed}\n Restart gateway to apply.`;
|
|
|
|
|
} catch (e) {
|
|
|
|
|
return `✗ Failed to write config: ${e.message}`;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmdCompact(args) {
|
|
|
|
|
const agent = args || "main";
|
|
|
|
|
const memDir = resolveMemDir(agent);
|
|
|
|
|
if (!memDir) return `Agent "${agent}" not found.`;
|
|
|
|
|
|
|
|
|
|
const statePath = path.join(memDir, "CURRENT_STATE.md");
|
|
|
|
|
const md = readFile(statePath);
|
|
|
|
|
if (!md) return `No state for "${agent}".`;
|
|
|
|
|
|
|
|
|
|
const lines = md.split("\n");
|
|
|
|
|
const originalLen = lines.length;
|
|
|
|
|
|
|
|
|
|
// Keep headers and first meaningful line of each section
|
|
|
|
|
const compacted = [];
|
|
|
|
|
let inSection = false;
|
|
|
|
|
let sectionLines = 0;
|
|
|
|
|
|
|
|
|
|
for (const line of lines) {
|
|
|
|
|
if (line.startsWith("# ") || line.startsWith("> Last updated")) {
|
|
|
|
|
compacted.push(line);
|
|
|
|
|
inSection = false;
|
|
|
|
|
} else if (line.startsWith("## ")) {
|
|
|
|
|
compacted.push(line);
|
|
|
|
|
inSection = true;
|
|
|
|
|
sectionLines = 0;
|
|
|
|
|
} else if (inSection) {
|
|
|
|
|
sectionLines++;
|
|
|
|
|
if (sectionLines <= 3 || line.startsWith("- ")) {
|
|
|
|
|
compacted.push(line);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
compacted.push(line);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Update timestamp
|
|
|
|
|
const result = compacted.join("\n")
|
|
|
|
|
.replace(/^> Last updated:.*$/m, `> Last updated: ${new Date().toISOString()}`);
|
|
|
|
|
|
|
|
|
|
fs.writeFileSync(statePath, result, "utf8");
|
|
|
|
|
return `✓ Compacted "${agent}" state: ${originalLen} → ${compacted.length} lines`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmdExport(args) {
|
|
|
|
|
const agent = args || "all";
|
|
|
|
|
const agents = agent === "all" ? discoverAgents() : [{ name: agent, memDir: resolveMemDir(agent) }];
|
|
|
|
|
|
|
|
|
|
if (agents.length === 0 || !agents[0]?.memDir) return `Agent "${agent}" not found.`;
|
|
|
|
|
|
|
|
|
|
const exportDir = path.join(BASE, "exports");
|
|
|
|
|
fs.mkdirSync(exportDir, { recursive: true });
|
|
|
|
|
|
|
|
|
|
const now = new Date();
|
|
|
|
|
const pad = (n) => String(n).padStart(2, "0");
|
|
|
|
|
const stamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}-${pad(now.getMinutes())}`;
|
|
|
|
|
const exportFile = path.join(exportDir, `mc-export-${stamp}.md`);
|
|
|
|
|
|
|
|
|
|
let content = `# Memory Continuity Export\n> Exported: ${now.toISOString()}\n\n`;
|
|
|
|
|
|
|
|
|
|
for (const { name, memDir } of agents) {
|
|
|
|
|
if (!memDir) continue;
|
|
|
|
|
content += `---\n# Agent: ${name}\n\n`;
|
|
|
|
|
|
|
|
|
|
// Current state
|
|
|
|
|
const state = readFile(path.join(memDir, "CURRENT_STATE.md"));
|
|
|
|
|
if (state) {
|
|
|
|
|
content += `## Current State\n\n${state}\n\n`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Archives
|
|
|
|
|
const archiveDir = path.join(memDir, "session_archive");
|
|
|
|
|
try {
|
|
|
|
|
const files = fs.readdirSync(archiveDir).filter(f => f.endsWith(".md")).sort().reverse();
|
|
|
|
|
if (files.length) {
|
|
|
|
|
content += `## Archives (${files.length})\n\n`;
|
|
|
|
|
for (const f of files) {
|
|
|
|
|
const ac = readFile(path.join(archiveDir, f));
|
|
|
|
|
if (ac) content += `### ${f.replace(".md", "")}\n\n${ac}\n\n`;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} catch {}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fs.writeFileSync(exportFile, content, "utf8");
|
|
|
|
|
const sizeMB = (Buffer.byteLength(content) / 1024).toFixed(1);
|
|
|
|
|
return `✓ Exported to:\n ${exportFile}\n ${agents.length} agent(s), ${sizeMB} KB`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function cmdHelp() {
|
|
|
|
|
return `MC Commands (Memory Continuity)
|
|
|
|
|
─────────────────────────────
|
|
|
|
|
/mc state [agent] View current state (default: main)
|
|
|
|
|
/mc state --all Overview of all agents
|
|
|
|
|
/mc history [agent] List archived sessions
|
|
|
|
|
/mc restore <N> [agent] Restore archive #N
|
|
|
|
|
/mc clear [agent] Clear state (archives first)
|
|
|
|
|
/mc search <keyword> Search across all memory
|
|
|
|
|
/mc settings View MC settings
|
|
|
|
|
/mc settings <k> <v> Update a setting
|
|
|
|
|
/mc compact [agent] Compress state file
|
|
|
|
|
/mc export [agent|all] Export memory to file`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ── Plugin entry point ──────────────────────────────────────────────────
|
|
|
|
|
|
|
|
|
|
export default function (api) {
|
|
|
|
|
console.log("[mc] MC plugin loading, registering /mc command...");
|
|
|
|
|
api.registerCommand({
|
|
|
|
|
name: "mc",
|
|
|
|
|
description: "Memory Continuity commands — state, history, search, settings, etc.",
|
|
|
|
|
acceptsArgs: true,
|
|
|
|
|
requireAuth: true,
|
|
|
|
|
handler: async (ctx) => {
|
|
|
|
|
const raw = (ctx.args || "").trim();
|
|
|
|
|
const spaceIdx = raw.indexOf(" ");
|
|
|
|
|
const subcmd = spaceIdx === -1 ? raw : raw.slice(0, spaceIdx);
|
|
|
|
|
const subargs = spaceIdx === -1 ? "" : raw.slice(spaceIdx + 1).trim();
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
let text;
|
|
|
|
|
switch (subcmd) {
|
|
|
|
|
case "state":
|
|
|
|
|
text = subargs === "--all" ? cmdStateAll() : cmdState(subargs || null);
|
|
|
|
|
break;
|
|
|
|
|
case "history": text = cmdHistory(subargs || null); break;
|
|
|
|
|
case "restore": text = cmdRestore(subargs); break;
|
|
|
|
|
case "clear": text = cmdClear(subargs || null); break;
|
|
|
|
|
case "search": text = cmdSearch(subargs); break;
|
|
|
|
|
case "settings": text = cmdSettings(subargs || null); break;
|
|
|
|
|
case "compact": text = cmdCompact(subargs || null); break;
|
|
|
|
|
case "export": text = cmdExport(subargs || null); break;
|
|
|
|
|
case "help": case "--help": case "-h": case "":
|
|
|
|
|
text = cmdHelp(); break;
|
|
|
|
|
default:
|
|
|
|
|
text = `Unknown subcommand: ${subcmd}\n\n${cmdHelp()}`;
|
|
|
|
|
}
|
|
|
|
|
return { text: mono(text) };
|
|
|
|
|
} catch (err) {
|
|
|
|
|
return { text: `MC error: ${err.message}` };
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
});
|
|
|
|
|
}
|
taodengandClaude Opus 4.6