memoclaw 1.5.0 → 1.7.0

package/dist/cli.mjs

@@ -5208,8 +5208,127 @@ function privateKeyToAccount(privateKey, options = {}) {
     source: "privateKey"
   };
 }
+// src/args.ts
+var BOOLEAN_FLAGS = new Set([
+  "help",
+  "version",
+  "raw",
+  "json",
+  "quiet",
+  "dryRun",
+  "verbose",
+  "noColor",
+  "force",
+  "count",
+  "wide"
+]);
+var SHORT_FLAGS = {
+  "-h": "help",
+  "-v": "version",
+  "-j": "json",
+  "-q": "quiet",
+  "-n": "namespace",
+  "-l": "limit",
+  "-t": "tags",
+  "-o": "output"
+};
+function parseArgs(args) {
+  const result = { _: [] };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg[0] === "-" && arg[1] !== "-" && arg.length >= 2) {
+      if (arg.length === 2 && SHORT_FLAGS[arg]) {
+        const key = SHORT_FLAGS[arg];
+        if (BOOLEAN_FLAGS.has(key)) {
+          result[key] = true;
+          i++;
+        } else {
+          const next = args[i + 1];
+          if (next !== undefined && !next.startsWith("-")) {
+            result[key] = next;
+            i += 2;
+          } else {
+            result[key] = true;
+            i++;
+          }
+        }
+      } else if (arg.length > 2 && !SHORT_FLAGS[arg]) {
+        const chars = arg.slice(1).split("");
+        let allValid = true;
+        for (const ch of chars) {
+          const flag = `-${ch}`;
+          if (!SHORT_FLAGS[flag]) {
+            allValid = false;
+            break;
+          }
+        }
+        if (allValid) {
+          for (let ci = 0;ci < chars.length; ci++) {
+            const flag = `-${chars[ci]}`;
+            const key = SHORT_FLAGS[flag];
+            if (BOOLEAN_FLAGS.has(key)) {
+              result[key] = true;
+            } else if (ci === chars.length - 1) {
+              const next = args[i + 1];
+              if (next !== undefined && !next.startsWith("-")) {
+                result[key] = next;
+                i++;
+              } else {
+                result[key] = true;
+              }
+            } else {
+              result[key] = true;
+            }
+          }
+          i++;
+        } else {
+          result._.push(arg);
+          i++;
+        }
+      } else {
+        result._.push(arg);
+        i++;
+      }
+    } else if (arg === "--") {
+      result._.push(...args.slice(i + 1));
+      break;
+    } else if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      let key;
+      let inlineValue;
+      if (eqIdx !== -1) {
+        key = arg.slice(2, eqIdx).replace(/-([a-z])/g, (_, ch) => ch.toUpperCase());
+        inlineValue = arg.slice(eqIdx + 1);
+      } else {
+        key = arg.slice(2).replace(/-([a-z])/g, (_, ch) => ch.toUpperCase());
+      }
+      if (inlineValue !== undefined) {
+        result[key] = inlineValue;
+        i++;
+      } else if (BOOLEAN_FLAGS.has(key)) {
+        result[key] = true;
+        i++;
+      } else {
+        const next = args[i + 1];
+        if (next !== undefined && (!next.startsWith("--") || /^--?\d/.test(next))) {
+          result[key] = next;
+          i += 2;
+        } else {
+          result[key] = true;
+          i++;
+        }
+      }
+    } else {
+      result._.push(arg);
+      i++;
+    }
+  }
+  return result;
+}
+
 // src/cli.ts
-var VERSION = "1.5.0";
+var VERSION = "1.7.0";
 var API_URL = process.env.MEMOCLAW_URL || "https://api.memoclaw.com";
 var PRIVATE_KEY = process.env.MEMOCLAW_PRIVATE_KEY;
 var NO_COLOR = !!process.env.NO_COLOR || !process.stdout.isTTY;
@@ -5260,57 +5379,6 @@ async function getWalletAuthHeader() {
   const signature = await account.signMessage({ message });
   return `${account.address}:${timestamp}:${signature}`;
 }
-var BOOLEAN_FLAGS = new Set([
-  "help",
-  "version",
-  "raw",
-  "json",
-  "quiet",
-  "dryRun",
-  "verbose"
-]);
-function parseArgs(args) {
-  const result = { _: [] };
-  let i = 0;
-  while (i < args.length) {
-    const arg = args[i];
-    if (arg === "-h" || arg === "--help") {
-      result.help = true;
-      i++;
-    } else if (arg === "-v" || arg === "--version") {
-      result.version = true;
-      i++;
-    } else if (arg === "-q" || arg === "--quiet") {
-      result.quiet = true;
-      i++;
-    } else if (arg === "-j" || arg === "--json") {
-      result.json = true;
-      i++;
-    } else if (arg === "--") {
-      result._.push(...args.slice(i + 1));
-      break;
-    } else if (arg.startsWith("--")) {
-      const key = arg.slice(2).replace(/-([a-z])/g, (_, ch) => ch.toUpperCase());
-      if (BOOLEAN_FLAGS.has(key)) {
-        result[key] = true;
-        i++;
-      } else {
-        const next = args[i + 1];
-        if (next !== undefined && !next.startsWith("--")) {
-          result[key] = next;
-          i += 2;
-        } else {
-          result[key] = true;
-          i++;
-        }
-      }
-    } else {
-      result._.push(arg);
-      i++;
-    }
-  }
-  return result;
-}
 async function readStdin() {
   if (process.stdin.isTTY)
     return null;
@@ -5374,6 +5442,11 @@ function table(rows, columns) {
     console.log(line);
   }
 }
+function progressBar(current, total, width = 30) {
+  const pct = Math.min(current / total, 1);
+  const filled = Math.round(pct * width);
+  return `${c.green}${"█".repeat(filled)}${c.dim}${"░".repeat(width - filled)}${c.reset} ${current}/${total}`;
+}
 async function request(method, path, body = null) {
   const url = `${API_URL}${path}`;
   const headers = { "Content-Type": "application/json" };
@@ -5382,7 +5455,21 @@ async function request(method, path, body = null) {
     options.body = JSON.stringify(body);
   const walletAuth = await getWalletAuthHeader();
   headers["x-wallet-auth"] = walletAuth;
-  let res = await fetch(url, { ...options, headers });
+  let res;
+  try {
+    res = await fetch(url, { ...options, headers });
+  } catch (e) {
+    if (e.code === "ECONNREFUSED" || e.cause?.code === "ECONNREFUSED") {
+      throw new Error(`Cannot connect to ${API_URL} — is the server running?`);
+    }
+    if (e.code === "ENOTFOUND" || e.cause?.code === "ENOTFOUND") {
+      throw new Error(`DNS lookup failed for ${API_URL} — check your internet connection`);
+    }
+    if (e.name === "AbortError") {
+      throw new Error(`Request timed out`);
+    }
+    throw new Error(`Network error: ${e.message}`);
+  }
   const freeTierRemaining = res.headers.get("x-free-tier-remaining");
   if (freeTierRemaining !== null && process.env.DEBUG) {
     console.error(`${c.dim}Free tier remaining: ${freeTierRemaining}${c.reset}`);
@@ -5426,7 +5513,7 @@ async function request(method, path, body = null) {
 }
 async function cmdStore(content, opts) {
   const body = { content };
-  if (opts.importance)
+  if (opts.importance != null && opts.importance !== true)
     body.importance = parseFloat(opts.importance);
   if (opts.tags)
     body.metadata = { tags: opts.tags.split(",").map((t) => t.trim()) };
@@ -5443,9 +5530,9 @@ async function cmdStore(content, opts) {
 }
 async function cmdRecall(query, opts) {
   const body = { query };
-  if (opts.limit)
+  if (opts.limit != null && opts.limit !== true)
     body.limit = parseInt(opts.limit);
-  if (opts.minSimilarity)
+  if (opts.minSimilarity != null && opts.minSimilarity !== true)
     body.min_similarity = parseFloat(opts.minSimilarity);
   if (opts.namespace)
     body.namespace = opts.namespace;
@@ -5454,6 +5541,11 @@ async function cmdRecall(query, opts) {
   const result = await request("POST", "/v1/recall", body);
   if (outputJson) {
     out(result);
+  } else if (opts.raw) {
+    const memories = result.memories || [];
+    for (const mem of memories) {
+      console.log(mem.content);
+    }
   } else {
     const memories = result.memories || [];
     if (memories.length === 0) {
@@ -5476,9 +5568,9 @@ async function cmdRecall(query, opts) {
 }
 async function cmdList(opts) {
   const params = new URLSearchParams;
-  if (opts.limit)
+  if (opts.limit != null && opts.limit !== true)
     params.set("limit", opts.limit);
-  if (opts.offset)
+  if (opts.offset != null && opts.offset !== true)
     params.set("offset", opts.offset);
   if (opts.namespace)
     params.set("namespace", opts.namespace);
@@ -5510,6 +5602,30 @@ async function cmdList(opts) {
     }
   }
 }
+async function cmdGet(id) {
+  const result = await request("GET", `/v1/memories/${id}`);
+  if (outputJson) {
+    out(result);
+  } else {
+    const mem = result.memory || result;
+    console.log(`${c.bold}ID:${c.reset}         ${mem.id || id}`);
+    console.log(`${c.bold}Content:${c.reset}    ${mem.content}`);
+    if (mem.importance !== undefined)
+      console.log(`${c.bold}Importance:${c.reset} ${mem.importance}`);
+    if (mem.namespace)
+      console.log(`${c.bold}Namespace:${c.reset}  ${mem.namespace}`);
+    if (mem.metadata?.tags?.length)
+      console.log(`${c.bold}Tags:${c.reset}       ${mem.metadata.tags.join(", ")}`);
+    if (mem.memory_type)
+      console.log(`${c.bold}Type:${c.reset}       ${mem.memory_type}`);
+    if (mem.created_at)
+      console.log(`${c.bold}Created:${c.reset}    ${new Date(mem.created_at).toLocaleString()}`);
+    if (mem.updated_at)
+      console.log(`${c.bold}Updated:${c.reset}    ${new Date(mem.updated_at).toLocaleString()}`);
+    if (mem.pinned)
+      console.log(`${c.bold}Pinned:${c.reset}     ${c.green}yes${c.reset}`);
+  }
+}
 async function cmdDelete(id) {
   const result = await request("DELETE", `/v1/memories/${id}`);
   if (outputJson) {
@@ -5520,7 +5636,7 @@ async function cmdDelete(id) {
 }
 async function cmdSuggested(opts) {
   const params = new URLSearchParams;
-  if (opts.limit)
+  if (opts.limit != null && opts.limit !== true)
     params.set("limit", opts.limit);
   if (opts.namespace)
     params.set("namespace", opts.namespace);
@@ -5555,7 +5671,7 @@ async function cmdUpdate(id, opts) {
   const body = {};
   if (opts.content)
     body.content = opts.content;
-  if (opts.importance)
+  if (opts.importance != null && opts.importance !== true)
     body.importance = parseFloat(opts.importance);
   if (opts.memoryType)
     body.memory_type = opts.memoryType;
@@ -5621,7 +5737,7 @@ async function cmdConsolidate(opts) {
   const body = {};
   if (opts.namespace)
     body.namespace = opts.namespace;
-  if (opts.minSimilarity)
+  if (opts.minSimilarity != null && opts.minSimilarity !== true)
     body.min_similarity = parseFloat(opts.minSimilarity);
   if (opts.mode)
     body.mode = opts.mode;
@@ -5779,7 +5895,7 @@ async function cmdImport(opts) {
       await request("POST", "/v1/store", body);
       imported++;
       if (!outputQuiet) {
-        process.stderr.write(`${c.dim}Imported ${imported}/${memories.length}...${c.reset}\r`);
+        process.stderr.write(`\r  ${progressBar(imported, memories.length)}`);
       }
     } catch (e) {
       failed++;
@@ -5833,11 +5949,99 @@ async function cmdStats(opts) {
     }
   }
 }
+async function cmdGraph(id, opts) {
+  const result = await request("GET", `/v1/memories/${id}`);
+  const mem = result.memory || result;
+  const relResult = await request("GET", `/v1/memories/${id}/relations`);
+  const relations = relResult.relations || [];
+  if (outputJson) {
+    out({ memory: mem, relations });
+    return;
+  }
+  const label = (m) => {
+    const text = (m.content || "").slice(0, 40);
+    return text.length < (m.content || "").length ? text + "…" : text;
+  };
+  const shortId = (s) => s?.slice(0, 8) || "?";
+  console.log();
+  console.log(`  ${c.bold}${c.cyan}[${shortId(mem.id)}]${c.reset} ${label(mem)}`);
+  if (relations.length === 0) {
+    console.log(`  ${c.dim}  └── (no relations)${c.reset}`);
+  } else {
+    for (let i = 0;i < relations.length; i++) {
+      const r = relations[i];
+      const isLast = i === relations.length - 1;
+      const branch = isLast ? "└" : "├";
+      const typeColor = {
+        contradicts: c.red,
+        supersedes: c.yellow,
+        supports: c.green,
+        derived_from: c.magenta,
+        related_to: c.blue
+      }[r.relation_type] || c.dim;
+      console.log(`  ${c.dim}  ${branch}──${c.reset} ${typeColor}${r.relation_type}${c.reset} ${c.dim}→${c.reset} ${c.cyan}[${shortId(r.target_id)}]${c.reset}`);
+    }
+  }
+  console.log();
+}
+async function cmdPurge(opts) {
+  if (!opts.force) {
+    if (!process.stdin.isTTY) {
+      throw new Error("Use --force to confirm purge in non-interactive mode");
+    }
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((r) => rl.question(`${c.red}⚠ Delete ALL memories${opts.namespace ? ` in namespace "${opts.namespace}"` : ""}? Type "yes" to confirm: ${c.reset}`, r));
+    rl.close();
+    if (answer.trim().toLowerCase() !== "yes") {
+      console.log(`${c.dim}Aborted.${c.reset}`);
+      return;
+    }
+  }
+  const params = new URLSearchParams({ limit: "100" });
+  if (opts.namespace)
+    params.set("namespace", opts.namespace);
+  let deleted = 0;
+  while (true) {
+    params.set("offset", "0");
+    const result = await request("GET", `/v1/memories?${params}`);
+    const memories = result.memories || result.data || [];
+    if (memories.length === 0)
+      break;
+    for (const mem of memories) {
+      await request("DELETE", `/v1/memories/${mem.id}`);
+      deleted++;
+      if (!outputQuiet)
+        process.stderr.write(`\r  ${progressBar(deleted, result.total || deleted)}`);
+    }
+  }
+  if (!outputQuiet)
+    process.stderr.write(`
+`);
+  if (outputJson) {
+    out({ deleted });
+  } else {
+    success(`Purged ${deleted} memories`);
+  }
+}
+async function cmdCount(opts) {
+  const params = new URLSearchParams({ limit: "1" });
+  if (opts.namespace)
+    params.set("namespace", opts.namespace);
+  const result = await request("GET", `/v1/memories?${params}`);
+  const total = result.total ?? "?";
+  if (outputJson) {
+    out({ count: total, namespace: opts.namespace || null });
+  } else {
+    console.log(String(total));
+  }
+}
 async function cmdCompletions(shell) {
   const commands = [
     "store",
     "recall",
     "list",
+    "get",
     "update",
     "delete",
     "ingest",
@@ -5849,7 +6053,12 @@ async function cmdCompletions(shell) {
     "export",
     "import",
     "stats",
-    "completions"
+    "browse",
+    "completions",
+    "config",
+    "graph",
+    "purge",
+    "count"
   ];
   if (shell === "bash") {
     console.log(`# Add to ~/.bashrc:
@@ -5878,6 +6087,186 @@ ${commands.map((cmd) => `complete -c memoclaw -n '__fish_use_subcommand' -a '${c
     throw new Error(`Unknown shell: ${shell}. Supported: bash, zsh, fish`);
   }
 }
+async function cmdConfig(subcmd, rest) {
+  if (subcmd === "show" || !subcmd) {
+    const config = {
+      MEMOCLAW_URL: API_URL,
+      MEMOCLAW_PRIVATE_KEY: PRIVATE_KEY ? `${PRIVATE_KEY.slice(0, 6)}…${PRIVATE_KEY.slice(-4)}` : "(not set)",
+      NO_COLOR: process.env.NO_COLOR || "(not set)",
+      DEBUG: process.env.DEBUG || "(not set)"
+    };
+    if (outputJson) {
+      out(config);
+    } else {
+      console.log(`${c.bold}MemoClaw Configuration${c.reset}`);
+      console.log(`${c.dim}${"─".repeat(50)}${c.reset}`);
+      for (const [key, val] of Object.entries(config)) {
+        const isSet = !val.includes("not set");
+        console.log(`  ${c.cyan}${key.padEnd(24)}${c.reset} ${isSet ? val : `${c.dim}${val}${c.reset}`}`);
+      }
+      console.log(`
+${c.dim}Set via environment variables or .env file${c.reset}`);
+    }
+  } else if (subcmd === "check") {
+    const issues = [];
+    if (!PRIVATE_KEY)
+      issues.push("MEMOCLAW_PRIVATE_KEY is not set");
+    else if (!PRIVATE_KEY.startsWith("0x"))
+      issues.push("MEMOCLAW_PRIVATE_KEY should start with 0x");
+    else if (PRIVATE_KEY.length !== 66)
+      issues.push(`MEMOCLAW_PRIVATE_KEY has wrong length (${PRIVATE_KEY.length}, expected 66)`);
+    if (outputJson) {
+      out({ valid: issues.length === 0, issues });
+    } else {
+      if (issues.length === 0) {
+        success("Configuration looks good!");
+        try {
+          const acct = getAccount();
+          info(`Wallet address: ${acct.address}`);
+        } catch {}
+      } else {
+        for (const issue of issues) {
+          console.log(`${c.red}✗${c.reset} ${issue}`);
+        }
+      }
+    }
+  } else {
+    throw new Error("Usage: config [show|check]");
+  }
+}
+async function cmdBrowse(opts) {
+  const readline = await import("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const prompt = (q) => new Promise((r) => rl.question(q, r));
+  console.log(`${c.bold}MemoClaw Interactive Browser${c.reset} ${c.dim}(type "help" or "q" to quit)${c.reset}`);
+  if (opts.namespace)
+    console.log(`${c.dim}Namespace: ${opts.namespace}${c.reset}`);
+  console.log();
+  let offset = 0;
+  const limit = 10;
+  while (true) {
+    const input = (await prompt(`${c.cyan}memoclaw>${c.reset} `)).trim();
+    if (!input)
+      continue;
+    if (input === "q" || input === "quit" || input === "exit")
+      break;
+    const parts = input.split(/\s+/);
+    const browsCmd = parts[0];
+    const browseArgs = parts.slice(1).join(" ");
+    try {
+      switch (browsCmd) {
+        case "help":
+          console.log(`${c.bold}Commands:${c.reset}
+  list / ls          List memories (paginated)
+  next / n           Next page
+  prev / p           Previous page
+  get <id>           Show memory details
+  recall <query>     Search memories
+  store <content>    Store a new memory
+  delete <id>        Delete a memory
+  stats              Show stats
+  q / quit           Exit browser`);
+          break;
+        case "list":
+        case "ls": {
+          offset = 0;
+          const params = new URLSearchParams({ limit: String(limit), offset: String(offset) });
+          if (opts.namespace)
+            params.set("namespace", opts.namespace);
+          const result = await request("GET", `/v1/memories?${params}`);
+          const memories = result.memories || result.data || [];
+          if (memories.length === 0) {
+            console.log(`${c.dim}No memories.${c.reset}`);
+            break;
+          }
+          for (const m of memories) {
+            const text = m.content?.length > 60 ? m.content.slice(0, 60) + "…" : m.content || "";
+            console.log(`  ${c.cyan}${(m.id || "?").slice(0, 8)}${c.reset}  ${text}`);
+          }
+          console.log(`${c.dim}─ showing ${offset + 1}-${offset + memories.length}${result.total ? ` of ${result.total}` : ""}${c.reset}`);
+          break;
+        }
+        case "next":
+        case "n":
+          offset += limit;
+          {
+            const params = new URLSearchParams({ limit: String(limit), offset: String(offset) });
+            if (opts.namespace)
+              params.set("namespace", opts.namespace);
+            const result = await request("GET", `/v1/memories?${params}`);
+            const memories = result.memories || result.data || [];
+            if (memories.length === 0) {
+              console.log(`${c.dim}No more memories.${c.reset}`);
+              offset = Math.max(0, offset - limit);
+              break;
+            }
+            for (const m of memories) {
+              const text = m.content?.length > 60 ? m.content.slice(0, 60) + "…" : m.content || "";
+              console.log(`  ${c.cyan}${(m.id || "?").slice(0, 8)}${c.reset}  ${text}`);
+            }
+            console.log(`${c.dim}─ showing ${offset + 1}-${offset + memories.length}${result.total ? ` of ${result.total}` : ""}${c.reset}`);
+          }
+          break;
+        case "prev":
+        case "p":
+          offset = Math.max(0, offset - limit);
+          {
+            const params = new URLSearchParams({ limit: String(limit), offset: String(offset) });
+            if (opts.namespace)
+              params.set("namespace", opts.namespace);
+            const result = await request("GET", `/v1/memories?${params}`);
+            const memories = result.memories || result.data || [];
+            for (const m of memories) {
+              const text = m.content?.length > 60 ? m.content.slice(0, 60) + "…" : m.content || "";
+              console.log(`  ${c.cyan}${(m.id || "?").slice(0, 8)}${c.reset}  ${text}`);
+            }
+            console.log(`${c.dim}─ showing ${offset + 1}-${offset + memories.length}${result.total ? ` of ${result.total}` : ""}${c.reset}`);
+          }
+          break;
+        case "get":
+          if (!browseArgs) {
+            console.log(`${c.red}Usage: get <id>${c.reset}`);
+            break;
+          }
+          await cmdGet(browseArgs);
+          break;
+        case "recall":
+        case "search":
+          if (!browseArgs) {
+            console.log(`${c.red}Usage: recall <query>${c.reset}`);
+            break;
+          }
+          await cmdRecall(browseArgs, opts);
+          break;
+        case "store":
+          if (!browseArgs) {
+            console.log(`${c.red}Usage: store <content>${c.reset}`);
+            break;
+          }
+          await cmdStore(browseArgs, opts);
+          break;
+        case "delete":
+        case "rm":
+          if (!browseArgs) {
+            console.log(`${c.red}Usage: delete <id>${c.reset}`);
+            break;
+          }
+          await cmdDelete(browseArgs);
+          break;
+        case "stats":
+          await cmdStats(opts);
+          break;
+        default:
+          console.log(`${c.dim}Unknown command. Type "help" for available commands.${c.reset}`);
+      }
+    } catch (e) {
+      console.log(`${c.red}Error:${c.reset} ${e.message}`);
+    }
+    console.log();
+  }
+  rl.close();
+  console.log(`${c.dim}Bye!${c.reset}`);
+}
 function printHelp(command) {
   if (command) {
     const subHelp = {
@@ -5932,6 +6321,50 @@ Show memory statistics and account info.
 
 Options:
   --namespace <name>     Filter by namespace`,
+      get: `${c.bold}memoclaw get${c.reset} <id>
+
+Retrieve a single memory by its ID.`,
+      config: `${c.bold}memoclaw config${c.reset} [show|check]
+
+Show or validate your MemoClaw configuration.
+
+Subcommands:
+  show       Display current configuration (default)
+  check      Validate configuration and test connectivity`,
+      browse: `${c.bold}memoclaw browse${c.reset} [options]
+
+Interactive memory browser (REPL). Explore, search, and manage
+memories in a persistent session.
+
+Options:
+  --namespace <name>     Filter by namespace
+
+Commands inside browser: list, get, recall, store, delete, stats, next, prev`,
+      graph: `${c.bold}memoclaw graph${c.reset} <id>
+
+Show an ASCII tree of a memory and its relations.
+
+Options:
+  --json                 Output as JSON`,
+      purge: `${c.bold}memoclaw purge${c.reset} [options]
+
+Delete ALL memories. Requires confirmation or --force.
+
+  ${c.dim}memoclaw purge --force${c.reset}
+  ${c.dim}memoclaw purge --namespace old-project --force${c.reset}
+
+Options:
+  --force                Skip confirmation prompt
+  --namespace <name>     Only purge memories in namespace`,
+      count: `${c.bold}memoclaw count${c.reset} [options]
+
+Print the total number of memories (pipe-friendly).
+
+  ${c.dim}memoclaw count${c.reset}
+  ${c.dim}memoclaw count --namespace project1${c.reset}
+
+Options:
+  --namespace <name>     Count only in namespace`,
       completions: `${c.bold}memoclaw completions${c.reset} <bash|zsh|fish>
 
 Generate shell completion scripts.
@@ -5956,6 +6389,7 @@ ${c.bold}Commands:${c.reset}
   ${c.cyan}store${c.reset} "content"        Store a memory (also accepts stdin)
   ${c.cyan}recall${c.reset} "query"         Search memories by similarity
   ${c.cyan}list${c.reset}                   List memories in a table
+  ${c.cyan}get${c.reset} <id>               Get a single memory by ID
   ${c.cyan}update${c.reset} <id>            Update a memory
   ${c.cyan}delete${c.reset} <id>            Delete a memory
   ${c.cyan}ingest${c.reset}                 Ingest raw text into memories
@@ -5968,12 +6402,23 @@ ${c.bold}Commands:${c.reset}
   ${c.cyan}export${c.reset}                 Export all memories as JSON
   ${c.cyan}import${c.reset}                 Import memories from JSON
   ${c.cyan}completions${c.reset} <shell>    Generate shell completions
+  ${c.cyan}browse${c.reset}                 Interactive memory browser (REPL)
+  ${c.cyan}config${c.reset} [show|check]    Show or validate configuration
+  ${c.cyan}graph${c.reset} <id>             ASCII visualization of memory relations
+  ${c.cyan}purge${c.reset}                  Delete ALL memories (requires --force or confirm)
+  ${c.cyan}count${c.reset}                  Quick memory count
 
 ${c.bold}Global Options:${c.reset}
   -h, --help             Show help (use with command for details)
   -v, --version          Show version
   -j, --json             Output as JSON (machine-readable)
   -q, --quiet            Suppress non-essential output
+  -n, --namespace <name> Filter/set namespace
+  -l, --limit <n>        Limit results
+  -t, --tags <a,b>       Comma-separated tags
+  --raw                  Raw output (content only, for piping)
+  --force                Skip confirmation prompts
+  --timeout <seconds>    Request timeout (default: 30)
 
 ${c.bold}Environment:${c.reset}
   MEMOCLAW_PRIVATE_KEY   Wallet private key for auth + payments
@@ -6009,6 +6454,7 @@ if (args.help) {
   printHelp(cmd);
   process.exit(0);
 }
+var TIMEOUT_MS = args.timeout ? parseInt(args.timeout) * 1000 : 30000;
 try {
   switch (cmd) {
     case "store": {
@@ -6031,6 +6477,11 @@ try {
     case "list":
       await cmdList(args);
       break;
+    case "get":
+      if (!rest[0])
+        throw new Error("Memory ID required");
+      await cmdGet(rest[0]);
+      break;
     case "update":
       if (!rest[0])
         throw new Error("Memory ID required");
@@ -6086,6 +6537,23 @@ try {
         throw new Error("Shell required: bash, zsh, or fish");
       await cmdCompletions(rest[0]);
       break;
+    case "browse":
+      await cmdBrowse(args);
+      break;
+    case "config":
+      await cmdConfig(rest[0], rest.slice(1));
+      break;
+    case "graph":
+      if (!rest[0])
+        throw new Error("Memory ID required");
+      await cmdGraph(rest[0], args);
+      break;
+    case "purge":
+      await cmdPurge(args);
+      break;
+    case "count":
+      await cmdCount(args);
+      break;
     case "help":
       printHelp(rest[0]);
       break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoclaw",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "MemoClaw CLI - Memory-as-a-Service for AI agents. 1000 free calls, then x402 micropayments.",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
   ],
   "scripts": {
     "build": "bun build src/cli.ts --outfile=dist/cli.mjs --target=node",
+    "test": "bun test",
     "prepublishOnly": "bun run build"
   },
   "keywords": [