@memrosetta/cli 0.3.2 → 0.4.1

package/dist/sync-WURX2HJZ.js

@@ -0,0 +1,321 @@
+import {
+  hasFlag,
+  optionalOption,
+  requireOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getConfig,
+  getDefaultDbPath,
+  writeConfig
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/sync.ts
+import { randomUUID } from "crypto";
+import { userInfo } from "os";
+function parseSubcommand(args) {
+  const first = args[0];
+  if (!first || first.startsWith("--")) return null;
+  if (first === "enable" || first === "disable" || first === "status" || first === "now" || first === "device-id") {
+    return first;
+  }
+  return null;
+}
+async function readHiddenInput(prompt) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  if (!stdin.isTTY) {
+    throw new Error("Interactive input requires a TTY. Use --key-stdin to pipe the key instead.");
+  }
+  stdout.write(prompt);
+  const wasRaw = stdin.isRaw;
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf-8");
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        const code = ch.charCodeAt(0);
+        if (code === 13 || code === 10) {
+          stdin.removeListener("data", onData);
+          stdin.setRawMode(wasRaw);
+          stdin.pause();
+          stdout.write("\n");
+          resolve(buffer);
+          return;
+        }
+        if (code === 3) {
+          stdin.removeListener("data", onData);
+          stdin.setRawMode(wasRaw);
+          stdin.pause();
+          stdout.write("\n");
+          reject(new Error("Aborted"));
+          return;
+        }
+        if (code === 127 || code === 8) {
+          buffer = buffer.slice(0, -1);
+          continue;
+        }
+        buffer += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function readStdinKey() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}
+async function testConnection(serverUrl, apiKey) {
+  const url = `${serverUrl.replace(/\/$/, "")}/sync/health`;
+  try {
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} ${res.statusText}`);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Sync server health check failed: ${msg}`);
+  }
+}
+async function withSyncClient(dbPath, config, fn) {
+  const Database = (await import("better-sqlite3")).default;
+  const { SyncClient, ensureSyncSchema } = await import("@memrosetta/sync-client");
+  if (!config.syncServerUrl || !config.syncApiKey || !config.syncDeviceId) {
+    throw new Error("Sync is not configured. Run: memrosetta sync enable --server <url>");
+  }
+  const db = new Database(dbPath);
+  try {
+    ensureSyncSchema(db);
+    const client = new SyncClient(db, {
+      serverUrl: config.syncServerUrl,
+      apiKey: config.syncApiKey,
+      deviceId: config.syncDeviceId,
+      userId: userInfo().username
+    });
+    return await fn(client, db);
+  } finally {
+    db.close();
+  }
+}
+async function runEnable(options) {
+  const { args, format } = options;
+  let serverUrl;
+  try {
+    serverUrl = requireOption(args, "--server", "server URL");
+  } catch (err) {
+    outputError(err instanceof Error ? err.message : String(err), format);
+    process.exitCode = 1;
+    return;
+  }
+  let apiKey = optionalOption(args, "--key");
+  if (hasFlag(args, "--key-stdin")) {
+    apiKey = await readStdinKey();
+  }
+  if (!apiKey) {
+    try {
+      apiKey = await readHiddenInput("API key: ");
+    } catch (err) {
+      outputError(err instanceof Error ? err.message : String(err), format);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  if (!apiKey) {
+    outputError("API key is required", format);
+    process.exitCode = 1;
+    return;
+  }
+  const skipTest = hasFlag(args, "--no-test");
+  if (!skipTest) {
+    try {
+      await testConnection(serverUrl, apiKey);
+    } catch (err) {
+      outputError(
+        `${err instanceof Error ? err.message : String(err)}
+Use --no-test to skip the health check.`,
+        format
+      );
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const existing = getConfig();
+  const deviceId = existing.syncDeviceId ?? `device-${randomUUID().slice(0, 8)}`;
+  writeConfig({
+    ...existing,
+    syncEnabled: true,
+    syncServerUrl: serverUrl,
+    syncApiKey: apiKey,
+    syncDeviceId: deviceId
+  });
+  if (format === "text") {
+    process.stdout.write("Sync enabled.\n");
+    process.stdout.write(`  Server:   ${serverUrl}
+`);
+    process.stdout.write(`  DeviceId: ${deviceId}
+`);
+    if (skipTest) {
+      process.stdout.write("  (health check skipped)\n");
+    }
+    return;
+  }
+  output({ enabled: true, serverUrl, deviceId, healthCheckSkipped: skipTest }, format);
+}
+function runDisable(options) {
+  const { format } = options;
+  const existing = getConfig();
+  writeConfig({
+    ...existing,
+    syncEnabled: false
+  });
+  if (format === "text") {
+    process.stdout.write("Sync disabled. (server URL and API key preserved for re-enable)\n");
+    return;
+  }
+  output({ enabled: false }, format);
+}
+async function runStatus(options) {
+  const { format, db } = options;
+  const config = getConfig();
+  const dbPath = db ?? config.dbPath ?? getDefaultDbPath();
+  if (!config.syncEnabled) {
+    if (format === "text") {
+      process.stdout.write("Sync: disabled\n");
+      if (config.syncServerUrl) {
+        process.stdout.write(`  Server:   ${config.syncServerUrl}
+`);
+      }
+      if (config.syncDeviceId) {
+        process.stdout.write(`  DeviceId: ${config.syncDeviceId}
+`);
+      }
+      return;
+    }
+    output(
+      {
+        enabled: false,
+        serverUrl: config.syncServerUrl ?? null,
+        deviceId: config.syncDeviceId ?? null
+      },
+      format
+    );
+    return;
+  }
+  try {
+    const status = await withSyncClient(dbPath, config, async (client) => client.getStatus());
+    if (format === "text") {
+      process.stdout.write("Sync: enabled\n");
+      process.stdout.write(`  Server:          ${status.serverUrl}
+`);
+      process.stdout.write(`  DeviceId:        ${status.deviceId}
+`);
+      process.stdout.write(`  Pending ops:     ${status.pendingOps}
+`);
+      process.stdout.write(`  Current cursor:  ${status.cursor}
+`);
+      process.stdout.write(
+        `  Last push:       ${status.lastPush.successAt ?? "never"}` + (status.lastPush.attemptAt && status.lastPush.attemptAt !== status.lastPush.successAt ? ` (last attempt: ${status.lastPush.attemptAt})` : "") + "\n"
+      );
+      process.stdout.write(
+        `  Last pull:       ${status.lastPull.successAt ?? "never"}` + (status.lastPull.attemptAt && status.lastPull.attemptAt !== status.lastPull.successAt ? ` (last attempt: ${status.lastPull.attemptAt})` : "") + "\n"
+      );
+      return;
+    }
+    output(status, format);
+  } catch (err) {
+    outputError(err instanceof Error ? err.message : String(err), format);
+    process.exitCode = 1;
+  }
+}
+async function runNow(options) {
+  const { args, format, db } = options;
+  const config = getConfig();
+  const dbPath = db ?? config.dbPath ?? getDefaultDbPath();
+  if (!config.syncEnabled) {
+    outputError("Sync is disabled. Run: memrosetta sync enable --server <url>", format);
+    process.exitCode = 1;
+    return;
+  }
+  const pushOnly = hasFlag(args, "--push-only");
+  const pullOnly = hasFlag(args, "--pull-only");
+  try {
+    const result = await withSyncClient(dbPath, config, async (client) => {
+      let pushed = 0;
+      let pulled = 0;
+      if (!pullOnly) {
+        const pushResult = await client.push();
+        pushed = pushResult.pushed;
+      }
+      if (!pushOnly) {
+        pulled = await client.pull();
+      }
+      return { pushed, pulled };
+    });
+    if (format === "text") {
+      process.stdout.write(`Sync complete. pushed=${result.pushed} pulled=${result.pulled}
+`);
+      return;
+    }
+    output(result, format);
+  } catch (err) {
+    outputError(err instanceof Error ? err.message : String(err), format);
+    process.exitCode = 1;
+  }
+}
+function runDeviceId(options) {
+  const { format } = options;
+  const config = getConfig();
+  if (!config.syncDeviceId) {
+    outputError("No deviceId set. Run: memrosetta sync enable --server <url>", format);
+    process.exitCode = 1;
+    return;
+  }
+  if (format === "text") {
+    process.stdout.write(`${config.syncDeviceId}
+`);
+    return;
+  }
+  output({ deviceId: config.syncDeviceId }, format);
+}
+async function run(options) {
+  const sub = parseSubcommand(options.args);
+  if (!sub) {
+    outputError(
+      "Usage: memrosetta sync <enable|disable|status|now|device-id>\n\n  enable    --server <url> [--key <key> | --key-stdin] [--no-test]\n  disable\n  status\n  now       [--push-only | --pull-only]\n  device-id\n",
+      options.format
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const rest = { ...options, args: options.args.slice(1) };
+  switch (sub) {
+    case "enable":
+      await runEnable(rest);
+      return;
+    case "disable":
+      runDisable(rest);
+      return;
+    case "status":
+      await runStatus(rest);
+      return;
+    case "now":
+      await runNow(rest);
+      return;
+    case "device-id":
+      runDeviceId(rest);
+      return;
+  }
+}
+export {
+  run
+};

package/dist/update-XJLMXCDZ.js

@@ -0,0 +1,36 @@
+// src/commands/update.ts
+import { execSync } from "child_process";
+import { createRequire } from "module";
+async function run() {
+  const require2 = createRequire(import.meta.url);
+  const pkg = require2("../../package.json");
+  const current = pkg.version;
+  process.stdout.write(`Current version: ${current}
+`);
+  process.stdout.write("Checking for updates...\n");
+  try {
+    const latest = execSync("npm view @memrosetta/cli version", { encoding: "utf-8" }).trim();
+    if (latest === current) {
+      process.stdout.write(`Already up to date (${current}).
+`);
+      return;
+    }
+    process.stdout.write(`New version available: ${latest}
+`);
+    process.stdout.write("Updating...\n");
+    execSync("npm install -g @memrosetta/cli@latest --force", {
+      stdio: "inherit"
+    });
+    process.stdout.write(`
+Updated: ${current} -> ${latest}
+`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`Update failed: ${message}
+`);
+    process.exitCode = 1;
+  }
+}
+export {
+  run
+};

package/dist/{working-memory-2RRQFX4Q.js → working-memory-2U33JHJB.js}

@@ -1,16 +1,20 @@
 import {
-  optionalOption,
-  requireOption
-} from "./chunk-F7ZMZ6HN.js";
+  optionalOption
+} from "./chunk-PW52BB6L.js";
+import {
+  getDefaultUserId
+} from "./chunk-TU5EHSDE.js";
+import {
+  getEngine
+} from "./chunk-2ZBEEETG.js";
 import {
-  getEngine,
   output
-} from "./chunk-MWLPPS7U.js";
+} from "./chunk-ET6TNQOJ.js";
 
 // src/commands/working-memory.ts
 async function run(options) {
   const { args, format, db, noEmbeddings } = options;
-  const userId = requireOption(args, "--user", "user");
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
   const maxTokensStr = optionalOption(args, "--max-tokens");
   const maxTokens = maxTokensStr ? parseInt(maxTokensStr, 10) : void 0;
   if (maxTokens !== void 0 && (isNaN(maxTokens) || maxTokens <= 0)) {

package/dist/working-memory-35TMFU3P.js

@@ -0,0 +1,53 @@
+import {
+  optionalOption
+} from "./chunk-HXZ7MAT6.js";
+import {
+  getDefaultUserId
+} from "./chunk-KSKRPUZZ.js";
+import {
+  getEngine
+} from "./chunk-EZVP3OY7.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+
+// src/commands/working-memory.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const maxTokensStr = optionalOption(args, "--max-tokens");
+  const maxTokens = maxTokensStr ? parseInt(maxTokensStr, 10) : void 0;
+  if (maxTokens !== void 0 && (isNaN(maxTokens) || maxTokens <= 0)) {
+    throw new Error("--max-tokens must be a positive integer");
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const memories = await engine.workingMemory(userId, maxTokens);
+  if (format === "text") {
+    if (memories.length === 0) {
+      process.stdout.write("No working memory found.\n");
+      return;
+    }
+    const totalTokens = memories.reduce(
+      (sum, m) => sum + Math.ceil(m.content.length / 4),
+      0
+    );
+    for (const memory of memories) {
+      const tier = memory.tier.toUpperCase();
+      const score = memory.activationScore.toFixed(2);
+      process.stdout.write(
+        `[${tier}|${score}] ${memory.content} (${memory.memoryType})
+`
+      );
+    }
+    process.stdout.write(
+      `
+${memories.length} memories, ~${totalTokens} tokens
+`
+    );
+    return;
+  }
+  output({ userId, maxTokens: maxTokens ?? 3e3, memories }, format);
+}
+export {
+  run
+};

package/dist/working-memory-IBWGIXLW.js

@@ -0,0 +1,53 @@
+import {
+  optionalOption
+} from "./chunk-TGGGIJC4.js";
+import {
+  getEngine
+} from "./chunk-POK32V2J.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-TU5EHSDE.js";
+
+// src/commands/working-memory.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const maxTokensStr = optionalOption(args, "--max-tokens");
+  const maxTokens = maxTokensStr ? parseInt(maxTokensStr, 10) : void 0;
+  if (maxTokens !== void 0 && (isNaN(maxTokens) || maxTokens <= 0)) {
+    throw new Error("--max-tokens must be a positive integer");
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const memories = await engine.workingMemory(userId, maxTokens);
+  if (format === "text") {
+    if (memories.length === 0) {
+      process.stdout.write("No working memory found.\n");
+      return;
+    }
+    const totalTokens = memories.reduce(
+      (sum, m) => sum + Math.ceil(m.content.length / 4),
+      0
+    );
+    for (const memory of memories) {
+      const tier = memory.tier.toUpperCase();
+      const score = memory.activationScore.toFixed(2);
+      process.stdout.write(
+        `[${tier}|${score}] ${memory.content} (${memory.memoryType})
+`
+      );
+    }
+    process.stdout.write(
+      `
+${memories.length} memories, ~${totalTokens} tokens
+`
+    );
+    return;
+  }
+  output({ userId, maxTokens: maxTokens ?? 3e3, memories }, format);
+}
+export {
+  run
+};

package/dist/working-memory-RZE3GYQZ.js

@@ -0,0 +1,53 @@
+import {
+  optionalOption
+} from "./chunk-HXZ7MAT6.js";
+import {
+  getDefaultUserId
+} from "./chunk-TU5EHSDE.js";
+import {
+  getEngine
+} from "./chunk-2ZBEEETG.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+
+// src/commands/working-memory.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const maxTokensStr = optionalOption(args, "--max-tokens");
+  const maxTokens = maxTokensStr ? parseInt(maxTokensStr, 10) : void 0;
+  if (maxTokens !== void 0 && (isNaN(maxTokens) || maxTokens <= 0)) {
+    throw new Error("--max-tokens must be a positive integer");
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const memories = await engine.workingMemory(userId, maxTokens);
+  if (format === "text") {
+    if (memories.length === 0) {
+      process.stdout.write("No working memory found.\n");
+      return;
+    }
+    const totalTokens = memories.reduce(
+      (sum, m) => sum + Math.ceil(m.content.length / 4),
+      0
+    );
+    for (const memory of memories) {
+      const tier = memory.tier.toUpperCase();
+      const score = memory.activationScore.toFixed(2);
+      process.stdout.write(
+        `[${tier}|${score}] ${memory.content} (${memory.memoryType})
+`
+      );
+    }
+    process.stdout.write(
+      `
+${memories.length} memories, ~${totalTokens} tokens
+`
+    );
+    return;
+  }
+  output({ userId, maxTokens: maxTokens ?? 3e3, memories }, format);
+}
+export {
+  run
+};

package/dist/working-memory-UYVEJJYW.js

@@ -0,0 +1,53 @@
+import {
+  optionalOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/working-memory.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const maxTokensStr = optionalOption(args, "--max-tokens");
+  const maxTokens = maxTokensStr ? parseInt(maxTokensStr, 10) : void 0;
+  if (maxTokens !== void 0 && (isNaN(maxTokens) || maxTokens <= 0)) {
+    throw new Error("--max-tokens must be a positive integer");
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const memories = await engine.workingMemory(userId, maxTokens);
+  if (format === "text") {
+    if (memories.length === 0) {
+      process.stdout.write("No working memory found.\n");
+      return;
+    }
+    const totalTokens = memories.reduce(
+      (sum, m) => sum + Math.ceil(m.content.length / 4),
+      0
+    );
+    for (const memory of memories) {
+      const tier = memory.tier.toUpperCase();
+      const score = memory.activationScore.toFixed(2);
+      process.stdout.write(
+        `[${tier}|${score}] ${memory.content} (${memory.memoryType})
+`
+      );
+    }
+    process.stdout.write(
+      `
+${memories.length} memories, ~${totalTokens} tokens
+`
+    );
+    return;
+  }
+  output({ userId, maxTokens: maxTokens ?? 3e3, memories }, format);
+}
+export {
+  run
+};

package/dist/working-memory-VP6L2QV6.js

@@ -0,0 +1,53 @@
+import {
+  optionalOption
+} from "./chunk-VZQURGWB.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/working-memory.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const maxTokensStr = optionalOption(args, "--max-tokens");
+  const maxTokens = maxTokensStr ? parseInt(maxTokensStr, 10) : void 0;
+  if (maxTokens !== void 0 && (isNaN(maxTokens) || maxTokens <= 0)) {
+    throw new Error("--max-tokens must be a positive integer");
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const memories = await engine.workingMemory(userId, maxTokens);
+  if (format === "text") {
+    if (memories.length === 0) {
+      process.stdout.write("No working memory found.\n");
+      return;
+    }
+    const totalTokens = memories.reduce(
+      (sum, m) => sum + Math.ceil(m.content.length / 4),
+      0
+    );
+    for (const memory of memories) {
+      const tier = memory.tier.toUpperCase();
+      const score = memory.activationScore.toFixed(2);
+      process.stdout.write(
+        `[${tier}|${score}] ${memory.content} (${memory.memoryType})
+`
+      );
+    }
+    process.stdout.write(
+      `
+${memories.length} memories, ~${totalTokens} tokens
+`
+    );
+    return;
+  }
+  output({ userId, maxTokens: maxTokens ?? 3e3, memories }, format);
+}
+export {
+  run
+};

package/dist/working-memory-WGB5DZ3B.js

@@ -0,0 +1,53 @@
+import {
+  optionalOption
+} from "./chunk-HXZ7MAT6.js";
+import {
+  getDefaultUserId
+} from "./chunk-JGE6RXXH.js";
+import {
+  getEngine
+} from "./chunk-2ZBEEETG.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+
+// src/commands/working-memory.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const maxTokensStr = optionalOption(args, "--max-tokens");
+  const maxTokens = maxTokensStr ? parseInt(maxTokensStr, 10) : void 0;
+  if (maxTokens !== void 0 && (isNaN(maxTokens) || maxTokens <= 0)) {
+    throw new Error("--max-tokens must be a positive integer");
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const memories = await engine.workingMemory(userId, maxTokens);
+  if (format === "text") {
+    if (memories.length === 0) {
+      process.stdout.write("No working memory found.\n");
+      return;
+    }
+    const totalTokens = memories.reduce(
+      (sum, m) => sum + Math.ceil(m.content.length / 4),
+      0
+    );
+    for (const memory of memories) {
+      const tier = memory.tier.toUpperCase();
+      const score = memory.activationScore.toFixed(2);
+      process.stdout.write(
+        `[${tier}|${score}] ${memory.content} (${memory.memoryType})
+`
+      );
+    }
+    process.stdout.write(
+      `
+${memories.length} memories, ~${totalTokens} tokens
+`
+    );
+    return;
+  }
+  output({ userId, maxTokens: maxTokens ?? 3e3, memories }, format);
+}
+export {
+  run
+};