@konglx/rotom 2.21.0

package/dist/cli/memory.js

@@ -0,0 +1,307 @@
+/**
+ * rotom memory — 记忆管理子命令。
+ *
+ * agent_memory 表的 CLI。note(agent_visible=0)用 `--type note` 查询/创建;
+ * memory(agent_visible=1)是默认。旧 `rotom note` 命令保留兼容,转调本模块。
+ */
+import { api, printJson, printTable, fail, flagStr, flagInt, requireFlag, } from "./common.js";
+import { route, qs, usage } from "./routes.js";
+import { createLogger } from "../shared/logger.js";
+const log = createLogger("mesh-cli-memory", { stream: "stderr" });
+const CATEGORIES = ["fact", "decision", "convention", "pitfall", "todo", "playbook", "note"];
+function parseTags(flags) {
+    const v = flagStr(flags, "tags");
+    if (!v)
+        return undefined;
+    if (v.startsWith("[")) {
+        try {
+            return JSON.parse(v);
+        }
+        catch {
+            fail(`--tags invalid JSON array: ${v}`);
+        }
+    }
+    return v.split(",").map(t => t.trim()).filter(Boolean);
+}
+function fmtPreview(s, len = 60) {
+    if (!s)
+        return "";
+    const flat = s.replace(/\n/g, " ");
+    return flat.length > len ? flat.slice(0, len) + "…" : flat;
+}
+export async function cmdMemory(agent, rest, flags) {
+    const sub = rest[0];
+    const scope = flagStr(flags, "scope") === "global" ? "global" : "group";
+    // ── search ───────────────────────────────────────────────────────────
+    if (sub === "search") {
+        const keyword = rest[1];
+        if (!keyword)
+            usage("memory search", "<keyword> [--scope group|global] [groupId] [--category <c>]");
+        const category = flagStr(flags, "category");
+        const limit = flagInt(flags, "limit") ?? 20;
+        let url;
+        if (scope === "global") {
+            url = `${route("/memory/search")}${qs({ q: keyword, limit, category })}`;
+        }
+        else {
+            const groupId = rest[2];
+            if (!groupId)
+                usage("memory search", "<keyword> <groupId> (group scope needs groupId)");
+            url = `${route("/groups/:groupId/memory/search", groupId)}${qs({ q: keyword, limit, category })}`;
+        }
+        const data = await api(agent, "GET", url);
+        // group search 返回 {group, global}; global search 返回数组
+        const rows = Array.isArray(data) ? data : [...(data.group || []), ...(data.global || [])];
+        printTable(rows.map((m) => ({
+            id: m.id,
+            scope: m.scope,
+            category: m.category,
+            key: m.key,
+            summary: fmtPreview(m.summary, 50),
+            by: m.created_by ?? "",
+        })), ["id", "scope", "category", "key", "summary", "by"]);
+        return;
+    }
+    // ── list ─────────────────────────────────────────────────────────────
+    if (sub === "list") {
+        const type = flagStr(flags, "type");
+        const category = flagStr(flags, "category");
+        const tags = parseTags(flags);
+        const includePending = flags["include-pending"] === true || flags["include-pending"] === "true";
+        let url;
+        if (scope === "global") {
+            url = route("/memory/global");
+        }
+        else {
+            const groupId = rest[1];
+            if (!groupId)
+                usage("memory list", "<groupId> [--scope group|global] [--type note|memory|all]");
+            url = route("/groups/:groupId/memory", groupId);
+        }
+        url += qs({
+            type: type && type !== "all" ? type : undefined,
+            category,
+            tags: tags && tags.length ? tags.join(",") : undefined,
+            includePending: includePending ? "true" : undefined,
+        });
+        const data = await api(agent, "GET", url);
+        printTable(data.map((m) => ({
+            id: m.id.slice(0, 8),
+            cat: m.category,
+            av: m.agent_visible ? "M" : "N", // M=memory N=note
+            key: m.key,
+            summary: fmtPreview(m.summary, 50),
+            by: m.created_by ?? "",
+            viewed: "",
+        })), ["id", "cat", "av", "key", "summary", "by"]);
+        return;
+    }
+    // ── get ──────────────────────────────────────────────────────────────
+    if (sub === "get") {
+        const id = rest[1];
+        if (!id)
+            usage("memory get", "<memoryId>");
+        const data = await api(agent, "GET", route("/memory/:id", id));
+        printJson(data);
+        return;
+    }
+    // ── add ──────────────────────────────────────────────────────────────
+    if (sub === "add") {
+        const key = requireFlag(flags, "key");
+        const value = requireFlag(flags, "value");
+        const category = flagStr(flags, "category");
+        if (!category || !CATEGORIES.includes(category)) {
+            fail(`--category required, one of: ${CATEGORIES.join(", ")}`);
+        }
+        const summary = flagStr(flags, "summary");
+        const tags = parseTags(flags) ?? [];
+        const visibility = flagStr(flags, "visibility");
+        // parseArgs: --no-agent-visible → flags["agent-visible"]=false;--agent-visible → true
+        const agentVisible = flags["agent-visible"] !== false;
+        const pendingReview = flags["pending"] === true;
+        const expiresAt = flagStr(flags, "expires");
+        const createdBy = flagStr(flags, "created-by") ?? agent.name;
+        let url;
+        let body = {
+            key, value, category, tags,
+            agentVisible,
+            createdBy,
+        };
+        if (summary)
+            body.summary = summary;
+        if (visibility)
+            body.visibility = visibility;
+        if (expiresAt)
+            body.expiresAt = expiresAt;
+        if (pendingReview)
+            body.pendingReview = true;
+        if (scope === "global") {
+            url = route("/memory/global");
+        }
+        else {
+            const groupId = rest[1];
+            if (!groupId)
+                usage("memory add", "<groupId> --key K --value V --category C [--scope global]");
+            url = route("/groups/:groupId/memory", groupId);
+        }
+        const data = await api(agent, "POST", url, body);
+        printJson(data);
+        return;
+    }
+    // ── update ────────────────────────────────────────────────────────────
+    if (sub === "update") {
+        const id = rest[1];
+        if (!id)
+            usage("memory update", "<memoryId> [--value V] [--summary S] [--tags t1,t2] [--category C] [--visibility V] [--agent-visible|--no-agent-visible]");
+        const body = {};
+        const value = flagStr(flags, "value");
+        const summary = flagStr(flags, "summary");
+        const tags = parseTags(flags);
+        const category = flagStr(flags, "category");
+        const visibility = flagStr(flags, "visibility");
+        if (value !== undefined)
+            body.value = value;
+        if (summary !== undefined)
+            body.summary = summary;
+        if (tags !== undefined)
+            body.tags = tags;
+        if (category) {
+            if (!CATEGORIES.includes(category))
+                fail(`--category one of: ${CATEGORIES.join(", ")}`);
+            body.category = category;
+        }
+        if (visibility)
+            body.visibility = visibility;
+        if (flags["agent-visible"] === true)
+            body.agentVisible = true;
+        if (flags["agent-visible"] === false)
+            body.agentVisible = false;
+        if (Object.keys(body).length === 0)
+            fail("no fields to update");
+        await api(agent, "PATCH", route("/memory/:id", id), body);
+        printJson({ ok: true });
+        return;
+    }
+    // ── remove / expire / promote ────────────────────────────────────────
+    if (sub === "remove") {
+        const id = rest[1];
+        if (!id)
+            usage("memory remove", "<memoryId>");
+        await api(agent, "DELETE", route("/memory/:id", id));
+        printJson({ ok: true });
+        return;
+    }
+    if (sub === "expire") {
+        const id = rest[1];
+        if (!id)
+            usage("memory expire", "<memoryId>");
+        await api(agent, "POST", route("/memory/:id/expire", id));
+        printJson({ ok: true });
+        return;
+    }
+    if (sub === "promote") {
+        const id = rest[1];
+        if (!id)
+            usage("memory promote", "<memoryId> --visibility global");
+        const visibility = flagStr(flags, "visibility");
+        if (visibility !== "global" && visibility !== "private" && visibility !== "group") {
+            fail("--visibility required: global | private | group");
+        }
+        await api(agent, "POST", route("/memory/:id/promote", id), { visibility });
+        printJson({ ok: true });
+        return;
+    }
+    // ── promote-to-skill(playbook memory → 全局 skill)────────────────────
+    if (sub === "promote-to-skill") {
+        const id = rest[1];
+        if (!id)
+            usage("memory promote-to-skill", "<memoryId> [--name N] [--description D]");
+        const name = flagStr(flags, "name");
+        const description = flagStr(flags, "description");
+        const body = { createdBy: agent.name };
+        if (name)
+            body.name = name;
+        if (description)
+            body.description = description;
+        const data = await api(agent, "POST", route("/memory/:id/promote-to-skill", id), body);
+        printJson(data);
+        return;
+    }
+    // ── 审核 ──────────────────────────────────────────────────────────────
+    if (sub === "pending") {
+        let url;
+        if (scope === "global") {
+            url = `${route("/memory/pending")}${qs({ scope: "global" })}`;
+        }
+        else {
+            const groupId = rest[1];
+            if (!groupId)
+                usage("memory pending", "<groupId> [--scope global]");
+            url = route("/groups/:groupId/memory/pending", groupId);
+        }
+        const data = await api(agent, "GET", url);
+        printTable(data.map((m) => ({
+            id: m.id.slice(0, 8),
+            cat: m.category,
+            key: m.key,
+            summary: fmtPreview(m.summary, 50),
+            by: m.created_by ?? "",
+        })), ["id", "cat", "key", "summary", "by"]);
+        return;
+    }
+    if (sub === "approve") {
+        const id = rest[1];
+        if (!id)
+            usage("memory approve", "<memoryId>");
+        await api(agent, "POST", route("/memory/:id/approve", id));
+        printJson({ ok: true });
+        return;
+    }
+    if (sub === "reject") {
+        const id = rest[1];
+        if (!id)
+            usage("memory reject", "<memoryId>");
+        await api(agent, "POST", route("/memory/:id/reject", id));
+        printJson({ ok: true });
+        return;
+    }
+    // ── stats ────────────────────────────────────────────────────────────
+    if (sub === "stats") {
+        let url;
+        if (scope === "global") {
+            url = `${route("/memory/stats")}${qs({ scope: "global" })}`;
+        }
+        else {
+            const groupId = rest[1];
+            if (!groupId)
+                usage("memory stats", "<groupId> [--scope global] [--stale]");
+            url = route("/groups/:groupId/memory/stats", groupId);
+        }
+        const data = await api(agent, "GET", url);
+        printJson(data);
+        if (flags["stale"] === true || flags["stale"] === "true") {
+            const minAge = flagInt(flags, "min-age") ?? 30;
+            // listMemory 不直接支持 stale,这里复用 stats 拿到的 topViewed 反推不够,
+            // 改用 list 接口 + 客户端过滤太重。直接走专用接口更合适,但未实现。
+            // 留作 TODO:加 /memory/stale 端点。当前用 stats 的 topViewed 近似。
+            log.warn(`stale 列表需 /memory/stale 端点,当前未实现;min-age=${minAge}`);
+        }
+        return;
+    }
+    fail(`unknown memory subcommand: ${sub || "(none)"}
+usage:
+  memory search <keyword> <groupId> [--scope group|global] [--category <c>]
+  memory list <groupId> [--scope group|global] [--type note|memory|all] [--category <c>] [--tags t1,t2]
+  memory get <memoryId>
+  memory add <groupId> --key K --value V --category C [--scope global] [--summary S] [--tags t1,t2]
+                   [--visibility group|global|private] [--no-agent-visible] [--pending] [--expires 7d]
+  memory update <id> [--value V] [--summary S] [--tags t1,t2] [--category C] [--visibility V] [--agent-visible|--no-agent-visible]
+  memory remove <id>
+  memory expire <id>
+  memory promote <id> --visibility global
+  memory promote-to-skill <memoryId> [--name N] [--description D]   # playbook → 全局 skill
+  memory pending <groupId> [--scope global]
+  memory approve <id>
+  memory reject <id>
+  memory stats <groupId> [--scope global]`);
+}

package/dist/cli/note.js

@@ -0,0 +1,68 @@
+/**
+ * rotom note — note list/show/create/update/delete.
+ */
+import { api, printJson, printTable, fail, flagStr, requireFlag, } from "./common.js";
+import { route, usage, unknownSubcommand } from "./routes.js";
+export async function cmdNote(agent, rest, flags) {
+    const sub = rest[0];
+    if (sub === "list") {
+        const groupId = rest[1];
+        if (!groupId)
+            usage("note list", "<groupId>");
+        const data = await api(agent, "GET", route("/groups/:groupId/notes", groupId));
+        printTable(data.map((n) => ({
+            id: n.id,
+            title: (n.title || "").slice(0, 60),
+            created_by: n.created_by,
+            updated_at: n.updated_at,
+        })), ["id", "title", "created_by", "updated_at"]);
+        return;
+    }
+    if (sub === "show") {
+        const id = rest[1];
+        if (!id)
+            usage("note show", "<noteId>");
+        const data = await api(agent, "GET", route("/notes/:id", id));
+        printJson(data);
+        return;
+    }
+    if (sub === "create") {
+        const groupId = rest[1];
+        if (!groupId)
+            usage("note create", "<groupId> --title T [--description D]");
+        const title = requireFlag(flags, "title");
+        const description = flagStr(flags, "description") || "";
+        const data = await api(agent, "POST", route("/groups/:groupId/notes", groupId), {
+            title, description, createdBy: agent.name,
+        });
+        printJson(data);
+        return;
+    }
+    if (sub === "update") {
+        const id = rest[1];
+        if (!id)
+            usage("note update", "<noteId> [--title T] [--description D]");
+        const title = flagStr(flags, "title");
+        const description = flagStr(flags, "description");
+        const body = {};
+        if (title !== undefined)
+            body.title = title;
+        if (description !== undefined)
+            body.description = description;
+        if (Object.keys(body).length === 0) {
+            fail("no fields to update — pass at least one of --title, --description");
+        }
+        const data = await api(agent, "PUT", route("/notes/:id", id), body);
+        printJson(data);
+        return;
+    }
+    if (sub === "delete") {
+        const id = rest[1];
+        if (!id)
+            usage("note delete", "<noteId>");
+        const data = await api(agent, "DELETE", route("/notes/:id", id));
+        printJson(data);
+        return;
+    }
+    unknownSubcommand("note", sub);
+}

package/dist/cli/repo.js

@@ -0,0 +1,77 @@
+/**
+ * rotom repo — 内置 repo bare clone + git worktree 缓存管理。
+ *
+ * 所有命令在本机 FS 操作(`~/.rotom/repos/<repo-id>.git/`),不需要 agent。
+ * 与 master/executor 一样属于 "本机维护命令"。
+ *
+ * 子命令:
+ *   list                          列出所有 bare clone + 各自 worktree 数 + 磁盘占用
+ *   prune [--remove-orphans]      清理孤儿 worktree 元数据,可选删除无引用的 bare clone
+ *   fetch <repo-id>               显式 git fetch --prune 某 bare clone
+ *   remove <repo-id>              删除 bare clone(要求无活跃 worktree)
+ */
+import { fail } from "./common.js";
+import { listBareClones, fetchBareClone, removeBareClone, pruneRepoCache, REPOS_ROOT, } from "../executor/repo-cache.js";
+function humanBytes(n) {
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}K`;
+    if (n < 1024 * 1024 * 1024)
+        return `${(n / 1024 / 1024).toFixed(1)}M`;
+    return `${(n / 1024 / 1024 / 1024).toFixed(2)}G`;
+}
+export function cmdRepo(rest, flags) {
+    const sub = rest[0];
+    const args = rest.slice(1);
+    switch (sub) {
+        case "list": return cmdList(flags);
+        case "prune": return cmdPrune(args, flags);
+        case "fetch": return cmdFetch(args, flags);
+        case "remove": return cmdRemove(args, flags);
+        default:
+            fail(`unknown repo subcommand: ${sub ?? "(none)"}\nUsage: rotom repo <list|prune|fetch|remove>`);
+    }
+}
+function cmdList(_flags) {
+    const clones = listBareClones();
+    if (clones.length === 0) {
+        process.stdout.write(`No bare clones in ${REPOS_ROOT}\n`);
+        return;
+    }
+    process.stdout.write(`Bare clone cache: ${REPOS_ROOT}\n\n`);
+    for (const c of clones) {
+        process.stdout.write(`${c.repoId}  (${humanBytes(c.sizeBytes)}, ${c.worktrees.length} worktree${c.worktrees.length === 1 ? "" : "s"})\n`);
+        for (const w of c.worktrees) {
+            process.stdout.write(`  - ${w.branch || "(detached)"}  ${w.path}\n`);
+        }
+    }
+}
+function cmdPrune(args, _flags) {
+    const removeOrphans = args.includes("--remove-orphans");
+    const r = pruneRepoCache({ removeOrphans });
+    process.stdout.write(`Pruned ${r.prunedWorktrees} orphan worktree(s).\n`);
+    if (r.removedClones.length > 0) {
+        process.stdout.write(`Removed orphan bare clones:\n`);
+        for (const id of r.removedClones)
+            process.stdout.write(`  - ${id}\n`);
+    }
+}
+function cmdFetch(args, _flags) {
+    const repoId = args[0];
+    if (!repoId)
+        fail("rotom repo fetch <repo-id>: missing repo-id");
+    const r = fetchBareClone(repoId);
+    if (!r.ok)
+        fail(`fetch failed: ${r.output}`);
+    process.stdout.write(r.output || `repo ${repoId} fetched.\n`);
+}
+function cmdRemove(args, _flags) {
+    const repoId = args[0];
+    if (!repoId)
+        fail("rotom repo remove <repo-id>: missing repo-id");
+    const r = removeBareClone(repoId);
+    if (!r.ok)
+        fail(r.error || `remove failed for ${repoId}`);
+    process.stdout.write(`Removed bare clone ${repoId}.\n`);
+}