mirror of
https://github.com/dtzp555-max/memory-continuity.git
synced 2026-07-21 21:15:07 +00:00
672 lines
24 KiB
JavaScript
672 lines
24 KiB
JavaScript
/**
|
|
* 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 state, archives, sessions, and summaries.";
|
|
|
|
const parts = args.trim().split(/\s+/);
|
|
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;
|
|
}
|
|
|
|
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;
|
|
|
|
// 1. Search current state
|
|
const state = readFile(path.join(memDir, "CURRENT_STATE.md"));
|
|
if (state && re.test(state)) {
|
|
re.lastIndex = 0;
|
|
const lines = state.split("\n").filter(l => re.test(l));
|
|
results.push({ agent: name, source: "CURRENT_STATE", type: "state", matches: lines.slice(0, 3) });
|
|
}
|
|
|
|
// 2. Search archives (most recent 30)
|
|
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)) {
|
|
re.lastIndex = 0;
|
|
const content = readFile(path.join(archiveDir, f));
|
|
if (content && re.test(content)) {
|
|
re.lastIndex = 0;
|
|
const lines = content.split("\n").filter(l => re.test(l));
|
|
results.push({ agent: name, source: f.replace(".md", ""), type: "archive", matches: lines.slice(0, 2) });
|
|
}
|
|
}
|
|
} catch {}
|
|
|
|
// 3. Search session logs (most recent 14 days)
|
|
const sessionsDir = path.join(memDir, "sessions");
|
|
try {
|
|
const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith(".md")).sort().reverse();
|
|
for (const f of files.slice(0, 14)) {
|
|
re.lastIndex = 0;
|
|
const content = readFile(path.join(sessionsDir, f));
|
|
if (content && re.test(content)) {
|
|
re.lastIndex = 0;
|
|
const lines = content.split("\n").filter(l => re.test(l));
|
|
results.push({ agent: name, source: f.replace(".md", ""), type: "session", matches: lines.slice(0, 2) });
|
|
}
|
|
}
|
|
} catch {}
|
|
|
|
// 4. Search summaries (daily + weekly)
|
|
for (const sub of ["daily", "weekly"]) {
|
|
const sumDir = path.join(memDir, "summaries", sub);
|
|
try {
|
|
const files = fs.readdirSync(sumDir).filter(f => f.endsWith(".md")).sort().reverse();
|
|
for (const f of files.slice(0, 10)) {
|
|
re.lastIndex = 0;
|
|
const content = readFile(path.join(sumDir, f));
|
|
if (content && re.test(content)) {
|
|
re.lastIndex = 0;
|
|
const lines = content.split("\n").filter(l => re.test(l));
|
|
results.push({ agent: name, source: f.replace(".md", ""), type: sub, matches: lines.slice(0, 2) });
|
|
}
|
|
}
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
if (!results.length) return `No matches for "${keyword}".`;
|
|
|
|
// Group by type for clearer output
|
|
let out = `Search: "${keyword}" (${results.length} hits)\n`;
|
|
out += "─────────────────────────────\n";
|
|
|
|
const typeOrder = ["state", "archive", "session", "daily", "weekly"];
|
|
const typeLabels = { state: "State", archive: "Archive", session: "Session", daily: "Daily", weekly: "Weekly" };
|
|
|
|
for (const type of typeOrder) {
|
|
const group = results.filter(r => r.type === type);
|
|
if (group.length === 0) continue;
|
|
|
|
out += `\n[${typeLabels[type]}]\n`;
|
|
for (const r of group.slice(0, 5)) {
|
|
out += ` ${r.agent}/${r.source}\n`;
|
|
for (const line of r.matches) {
|
|
out += ` ${truncate(line.trim(), 75)}\n`;
|
|
}
|
|
}
|
|
if (group.length > 5) out += ` ... +${group.length - 5} more\n`;
|
|
}
|
|
|
|
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 cmdSessions(args) {
|
|
const parts = (args || "").trim().split(/\s+/);
|
|
const agent = parts.find(p => !p.startsWith("-") && !p.startsWith("2")) || "main";
|
|
const dateArg = parts.find(p => /^\d{4}-\d{2}-\d{2}$/.test(p));
|
|
|
|
const memDir = resolveMemDir(agent);
|
|
if (!memDir) return `Agent "${agent}" not found.`;
|
|
|
|
const sessionsDir = path.join(memDir, "sessions");
|
|
let files;
|
|
try { files = fs.readdirSync(sessionsDir).filter(f => f.endsWith(".md")).sort().reverse(); }
|
|
catch { return `No session logs for "${agent}".`; }
|
|
|
|
if (!files.length) return `No session logs for "${agent}".`;
|
|
|
|
// If date specified, show that day's log
|
|
if (dateArg) {
|
|
const target = `${dateArg}.md`;
|
|
const content = readFile(path.join(sessionsDir, target));
|
|
if (!content) return `No session log for ${dateArg}.`;
|
|
// Truncate to last 50 lines to stay compact
|
|
const lines = content.split("\n");
|
|
const shown = lines.length > 50 ? lines.slice(-50) : lines;
|
|
let out = shown.join("\n");
|
|
if (lines.length > 50) out = `... (${lines.length - 50} earlier lines omitted)\n\n` + out;
|
|
return out;
|
|
}
|
|
|
|
// List recent session logs
|
|
let out = `Session Logs: ${agent} (${files.length} days)\n`;
|
|
out += "─────────────────────────────\n";
|
|
|
|
for (const f of files.slice(0, 14)) {
|
|
const date = f.replace(".md", "");
|
|
const content = readFile(path.join(sessionsDir, f));
|
|
// Count session entries (### HH:MM headers)
|
|
const sessionCount = content ? (content.match(/^### \d{2}:\d{2}/gm) || []).length : 0;
|
|
out += `${date} ${String(sessionCount).padStart(3)} session(s)\n`;
|
|
}
|
|
|
|
if (files.length > 14) out += `\n ... and ${files.length - 14} more days`;
|
|
out += `\n\nUse /mc sessions <YYYY-MM-DD> to view a specific day.`;
|
|
return out.trimEnd();
|
|
}
|
|
|
|
function cmdTags(args) {
|
|
const agent = args || "main";
|
|
const memDir = resolveMemDir(agent);
|
|
if (!memDir) return `Agent "${agent}" not found.`;
|
|
|
|
const tagsFile = path.join(memDir, "tags.md");
|
|
const content = readFile(tagsFile);
|
|
if (!content) return `No tags for "${agent}".`;
|
|
|
|
// Parse tags and their date counts
|
|
const tagSections = content.split(/^## /gm).filter(s => s.trim());
|
|
if (tagSections.length === 0) return `No tags for "${agent}".`;
|
|
|
|
let out = `Tags: ${agent} (${tagSections.length} tags)\n`;
|
|
out += "─────────────────────────────\n";
|
|
|
|
const tags = [];
|
|
for (const section of tagSections) {
|
|
const lines = section.trim().split("\n");
|
|
const tag = lines[0].trim();
|
|
if (!tag.startsWith("#")) continue;
|
|
const dates = lines.filter(l => l.startsWith("- "));
|
|
tags.push({ tag, count: dates.length, latest: dates[0]?.replace("- ", "") || "?" });
|
|
}
|
|
|
|
// Sort by count descending
|
|
tags.sort((a, b) => b.count - a.count);
|
|
|
|
for (const { tag, count, latest } of tags.slice(0, 30)) {
|
|
out += `${tag.padEnd(25)} ${String(count).padStart(3)} days latest: ${latest}\n`;
|
|
}
|
|
|
|
if (tags.length > 30) out += `\n ... and ${tags.length - 30} more tags`;
|
|
return out.trimEnd();
|
|
}
|
|
|
|
function cmdSummary(args) {
|
|
const parts = (args || "").trim().split(/\s+/);
|
|
const agent = parts.find(p => !p.startsWith("-") && !/^\d{4}/.test(p) && p !== "daily" && p !== "weekly") || "main";
|
|
const typeArg = parts.find(p => p === "daily" || p === "weekly");
|
|
const dateArg = parts.find(p => /^\d{4}/.test(p));
|
|
|
|
const memDir = resolveMemDir(agent);
|
|
if (!memDir) return `Agent "${agent}" not found.`;
|
|
|
|
// If specific date given, show that summary
|
|
if (dateArg) {
|
|
const type = typeArg || (dateArg.includes("W") ? "weekly" : "daily");
|
|
const sumFile = path.join(memDir, "summaries", type, `${dateArg}.md`);
|
|
const content = readFile(sumFile);
|
|
if (!content) return `No ${type} summary for ${dateArg}.`;
|
|
return content;
|
|
}
|
|
|
|
// List available summaries
|
|
const types = typeArg ? [typeArg] : ["daily", "weekly"];
|
|
let out = `Summaries: ${agent}\n`;
|
|
out += "─────────────────────────────\n";
|
|
|
|
for (const type of types) {
|
|
const sumDir = path.join(memDir, "summaries", type);
|
|
let files;
|
|
try { files = fs.readdirSync(sumDir).filter(f => f.endsWith(".md")).sort().reverse(); }
|
|
catch { continue; }
|
|
|
|
if (files.length === 0) continue;
|
|
|
|
out += `\n[${type.charAt(0).toUpperCase() + type.slice(1)}] (${files.length})\n`;
|
|
for (const f of files.slice(0, 10)) {
|
|
const name = f.replace(".md", "");
|
|
const content = readFile(path.join(sumDir, f));
|
|
const sessMatch = content?.match(/\*\*(?:Total s|S)essions:\*\*\s*(\d+)/);
|
|
const sessions = sessMatch ? sessMatch[1] : "?";
|
|
out += ` ${name} ${sessions} session(s)\n`;
|
|
}
|
|
if (files.length > 10) out += ` ... +${files.length - 10} more\n`;
|
|
}
|
|
|
|
out += `\nUse /mc summary <YYYY-MM-DD> or /mc summary <YYYY-Www> to view details.`;
|
|
return out.trimEnd();
|
|
}
|
|
|
|
function cmdHelp() {
|
|
return `MC Commands (Memory Continuity)
|
|
─────────────────────────────
|
|
/mc state [agent] View current state (default: main)
|
|
/mc state --all Overview of all agents
|
|
/mc sessions [date] Session logs (daily activity)
|
|
/mc summary [daily|weekly] List or view summaries
|
|
/mc tags [agent] View tag index
|
|
/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 "sessions": text = cmdSessions(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 "tags": text = cmdTags(subargs || null); break;
|
|
case "summary": text = cmdSummary(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}` };
|
|
}
|
|
},
|
|
});
|
|
}
|