@heyamiko/amiko-cli 0.9.8 → 0.9.9-beta.1

package/dist/index.js

@@ -22012,6 +22012,347 @@ function registerNotificationsCommand(program2) {
   });
 }
 
+// src/commands/memory.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "node:fs";
+import { dirname, isAbsolute, normalize, resolve as resolve2 } from "node:path";
+var VALID_CATEGORIES = ["fact", "preference", "pattern", "decision", "context"];
+var VALID_SOURCES = ["chat", "file", "manual"];
+var DEFAULT_WORKSPACE = "/data/.openclaw/workspace";
+var SYNC_BATCH_SIZE = 100;
+function fail(msg) {
+  console.error(error(msg));
+  process.exit(1);
+}
+function parseTags(raw) {
+  if (!raw)
+    return;
+  const tags = raw.split(",").map((t) => t.trim()).filter(Boolean);
+  return tags.length ? tags : undefined;
+}
+function fmtMemory(m) {
+  console.log("");
+  console.log(label("ID", m.id));
+  console.log(label("Category", m.category));
+  console.log(label("Source", m.source));
+  if (m.tags && m.tags.length)
+    console.log(label("Tags", m.tags.join(", ")));
+  if (typeof m.score === "number")
+    console.log(label("Score", m.score.toFixed(3)));
+  if (m.created_at)
+    console.log(label("Created", m.created_at.slice(0, 19)));
+  console.log(m.content);
+}
+function registerMemoryCommand(program2) {
+  const memory = program2.command("memory").description("Manage cross-agent memories — add, list, search, remove, sync local files");
+  memory.command("add <content>").description("Add a single memory directly").option("--category <cat>", `Category (${VALID_CATEGORIES.join("|")})`, "fact").option("--tags <list>", "Comma-separated tags (max 10)").option("--source <src>", `Source (${VALID_SOURCES.join("|")})`, "manual").option("--twin <twinId>", "Override twin_id (defaults to scopedTwinId)").option("--json", "Output as JSON").action(async (content, opts) => {
+    if (!content || !content.trim())
+      fail("Content is required and cannot be empty.");
+    if (opts.category && !VALID_CATEGORIES.includes(opts.category)) {
+      fail(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`);
+    }
+    if (opts.source && !VALID_SOURCES.includes(opts.source)) {
+      fail(`Invalid source. Must be one of: ${VALID_SOURCES.join(", ")}`);
+    }
+    const tags = parseTags(opts.tags);
+    if (tags && tags.length > 10)
+      fail("Max 10 tags.");
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Saving memory...").start();
+    try {
+      const data = await amikoWebFetch(auth, "/api/memories", {
+        method: "POST",
+        body: {
+          content: content.trim(),
+          category: opts.category,
+          tags,
+          source: opts.source,
+          twin_id: opts.twin
+        }
+      });
+      spinner?.stop();
+      renderOutput(data, (d) => {
+        console.log(success("Memory saved"));
+        fmtMemory(d.memory);
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("list").description("List the caller's memories (newest first)").option("--limit <n>", "Max results (1–100)", "25").option("--offset <n>", "Pagination offset", "0").option("--category <cat>", `Filter (${VALID_CATEGORIES.join("|")})`).option("--source <src>", `Filter (${VALID_SOURCES.join("|")})`).option("--json", "Output as JSON").action(async (opts) => {
+    if (opts.category && !VALID_CATEGORIES.includes(opts.category)) {
+      fail(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`);
+    }
+    if (opts.source && !VALID_SOURCES.includes(opts.source)) {
+      fail(`Invalid source. Must be one of: ${VALID_SOURCES.join(", ")}`);
+    }
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Loading memories...").start();
+    try {
+      const data = await amikoWebFetch(auth, "/api/memories", {
+        query: {
+          limit: opts.limit,
+          offset: opts.offset,
+          category: opts.category,
+          source: opts.source
+        }
+      });
+      spinner?.stop();
+      renderOutput(data, (d) => {
+        if (!d.items.length) {
+          console.log(dim("No memories."));
+          return;
+        }
+        console.log(heading(`Memories — ${d.items.length} of ${d.total}`));
+        for (const m of d.items)
+          fmtMemory(m);
+        if (d.has_more) {
+          const next = Number(opts.offset || "0") + d.items.length;
+          console.log("");
+          console.log(dim(`More available — pass --offset ${next}`));
+        }
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("search <query>").description("Hybrid search across the caller's memories").option("--limit <n>", "Max results (1–100)", "25").option("--category <cat>", `Filter (${VALID_CATEGORIES.join("|")})`).option("--json", "Output as JSON").action(async (query, opts) => {
+    if (!query || !query.trim())
+      fail("Query is required.");
+    if (opts.category && !VALID_CATEGORIES.includes(opts.category)) {
+      fail(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`);
+    }
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Searching...").start();
+    try {
+      const data = await amikoWebFetch(auth, "/api/memories", {
+        query: {
+          q: query,
+          limit: opts.limit,
+          category: opts.category
+        }
+      });
+      spinner?.stop();
+      renderOutput(data, (d) => {
+        if (!d.items.length) {
+          console.log(dim("No matches."));
+          return;
+        }
+        console.log(heading(`Matches — ${d.items.length} of ${d.total}`));
+        for (const m of d.items)
+          fmtMemory(m);
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("rm <id>").description("Soft-delete a memory by id").option("--json", "Output as JSON").action(async (id, opts) => {
+    if (!id)
+      fail("Memory id is required.");
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Deleting...").start();
+    try {
+      const data = await amikoWebFetch(auth, `/api/memories/${encodeURIComponent(id)}`, { method: "DELETE" });
+      spinner?.stop();
+      renderOutput(data, () => console.log(success(`Deleted memory ${id}`)), { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("status").description("Show counts of memories and synced memory files").option("--json", "Output as JSON").action(async (opts) => {
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Loading status...").start();
+    try {
+      const [memories, files] = await Promise.all([
+        amikoWebFetch(auth, "/api/memories", {
+          query: { limit: "1" }
+        }),
+        amikoWebFetch(auth, "/api/memory-files", { query: { limit: "1" } })
+      ]);
+      spinner?.stop();
+      const fileTotal = files.total ?? files.items?.length ?? 0;
+      renderOutput({ memories: memories.total, memory_files: fileTotal }, (d) => {
+        console.log(heading("Memory status"));
+        console.log(label("Memories", String(d.memories)));
+        console.log(label("Memory files", String(d.memory_files)));
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+  memory.command("sync").description("Sync MEMORY.md and referenced files to the platform (one-way: local → server)").option("--path <dir>", `Workspace dir containing MEMORY.md (default ${DEFAULT_WORKSPACE})`).option("--dry-run", "Print what would be synced without uploading").option("--prune", "Delete server-side memory files that no longer exist locally").option("--json", "Output as JSON").action(async (opts) => {
+    const root = resolve2(opts.path || DEFAULT_WORKSPACE);
+    const indexPath = resolve2(root, "MEMORY.md");
+    if (!existsSync3(indexPath)) {
+      fail(`MEMORY.md not found at ${indexPath}`);
+    }
+    const collected = collectMemoryFiles(root, indexPath);
+    if (collected.errors.length && !opts.json) {
+      for (const e of collected.errors)
+        console.error(error(e));
+    }
+    const files = collected.files;
+    if (opts.dryRun) {
+      renderOutput({ root, files: files.map((f) => f.path), prune: !!opts.prune }, (d) => {
+        console.log(heading(`Dry run — ${d.files.length} file(s)`));
+        for (const p of d.files)
+          console.log(`  ${p}`);
+        if (d.prune)
+          console.log(dim("--prune would remove server files not listed above."));
+      }, { json: opts.json });
+      return;
+    }
+    if (!files.length) {
+      renderOutput({ synced: 0, changed: 0, errors: 0, extracted: 0 }, () => console.log(dim("Nothing to sync.")), { json: opts.json });
+      return;
+    }
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora(`Syncing ${files.length} file(s)...`).start();
+    try {
+      const allResults = [];
+      for (let i = 0;i < files.length; i += SYNC_BATCH_SIZE) {
+        const chunk = files.slice(i, i + SYNC_BATCH_SIZE);
+        const data = await amikoWebFetch(auth, "/api/memory-files/bulk", {
+          method: "POST",
+          body: { files: chunk }
+        });
+        allResults.push(...data.results);
+      }
+      let pruned = 0;
+      const pruneErrors = [];
+      if (opts.prune) {
+        const localPaths = new Set(files.map((f) => f.path));
+        const remote = await fetchAllMemoryFiles(auth);
+        const stale = remote.filter((f) => !localPaths.has(f.path));
+        for (const f of stale) {
+          try {
+            await amikoWebFetch(auth, `/api/memory-files/${encodeURIComponent(f.id)}`, { method: "DELETE" });
+            pruned++;
+          } catch (e) {
+            pruneErrors.push(`${f.path}: ${e instanceof Error ? e.message : String(e)}`);
+          }
+        }
+      }
+      spinner?.stop();
+      const changed = allResults.filter((r) => r.changed).length;
+      const errors2 = allResults.filter((r) => r.error).length;
+      const extracted = allResults.reduce((acc, r) => acc + (r.extracted ?? 0), 0);
+      renderOutput({
+        synced: allResults.length,
+        changed,
+        errors: errors2,
+        extracted,
+        pruned,
+        prune_errors: pruneErrors,
+        results: allResults
+      }, (d) => {
+        console.log(success(`${d.synced} file(s) synced (${d.changed} changed, ${d.errors} errors), ${d.extracted} memories extracted`));
+        for (const r of allResults) {
+          if (r.error) {
+            console.log(error(`${r.path}: ${r.error}`));
+          } else if (r.changed) {
+            console.log(`  ${r.path} ${dim(`→ ${r.extracted ?? 0} extracted`)}`);
+          } else {
+            console.log(`  ${r.path} ${dim("(unchanged)")}`);
+          }
+        }
+        if (opts.prune) {
+          console.log("");
+          console.log(label("Pruned", String(d.pruned)));
+          for (const e of pruneErrors)
+            console.log(error(e));
+        }
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      fail(e instanceof Error ? e.message : String(e));
+    }
+  });
+}
+function collectMemoryFiles(root, indexPath) {
+  const errors2 = [];
+  const seen = new Set;
+  const files = [];
+  const indexContent = safeRead(indexPath, errors2);
+  if (indexContent === null)
+    return { files, errors: errors2 };
+  pushFile(files, seen, indexPath, indexContent, root);
+  const indexDir = dirname(indexPath);
+  for (const ref of extractMarkdownLinks(indexContent)) {
+    if (isExternal(ref))
+      continue;
+    const abs = normalize(isAbsolute(ref) ? ref : resolve2(indexDir, ref));
+    if (!abs.startsWith(root)) {
+      errors2.push(`Skipping ${ref}: outside workspace ${root}`);
+      continue;
+    }
+    if (!existsSync3(abs)) {
+      errors2.push(`Referenced file missing: ${ref}`);
+      continue;
+    }
+    const st = statSync(abs);
+    if (!st.isFile())
+      continue;
+    const content = safeRead(abs, errors2);
+    if (content === null)
+      continue;
+    pushFile(files, seen, abs, content, root);
+  }
+  return { files, errors: errors2 };
+}
+function pushFile(files, seen, abs, content, root) {
+  const key = relativeKey(abs, root);
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  files.push({ path: key, content });
+}
+function relativeKey(abs, root) {
+  const rel = abs.startsWith(root) ? abs.slice(root.length) : abs;
+  return rel.replace(/^\/+/, "");
+}
+function safeRead(path2, errors2) {
+  try {
+    return readFileSync2(path2, "utf-8");
+  } catch (e) {
+    errors2.push(`Failed to read ${path2}: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+function extractMarkdownLinks(md) {
+  const out = [];
+  const re = /\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+  let m;
+  while ((m = re.exec(md)) !== null) {
+    const target = m[1].split("#")[0];
+    if (target)
+      out.push(target);
+  }
+  return out;
+}
+function isExternal(ref) {
+  return /^[a-z][a-z0-9+.-]*:/i.test(ref) || ref.startsWith("//");
+}
+async function fetchAllMemoryFiles(auth) {
+  const all = [];
+  let offset = 0;
+  const limit = 100;
+  for (;; ) {
+    const data = await amikoWebFetch(auth, "/api/memory-files", {
+      query: { limit: String(limit), offset: String(offset) }
+    });
+    all.push(...data.items ?? []);
+    if (!data.has_more || !data.items?.length)
+      break;
+    offset += data.items.length;
+  }
+  return all;
+}
+
 // src/commands/wallets.ts
 function formatBalance(b) {
   const n = Number(b.amount) / 10 ** b.decimals;
@@ -22255,4 +22596,5 @@ registerReviewCommand(review);
 registerComposioCommand(composio);
 registerConversationCommand(conversation);
 registerNotificationsCommand(notifications);
+registerMemoryCommand(program2);
 program2.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyamiko/amiko-cli",
-  "version": "0.9.8",
+  "version": "0.9.9-beta.1",
   "description": "Amiko CLI — swap tokens, manage credits, bridge cross-chain, and call marketplace agents",
   "type": "module",
   "bin": {