@memrosetta/cli 0.4.8 → 0.5.0

package/dist/sync-EHYMBZHE.js

@@ -0,0 +1,542 @@
+import {
+  deterministicOpId,
+  openCliSyncContext
+} from "./chunk-2MO65JLK.js";
+import {
+  hasFlag,
+  optionalOption,
+  requireOption
+} from "./chunk-SYPVELIW.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 { readFileSync } from "fs";
+import { userInfo, platform } from "os";
+import { createInterface } from "readline";
+var ENV_API_KEY = "MEMROSETTA_SYNC_API_KEY";
+var KEY_SOURCE_HINT = [
+  "API key required. Use exactly one of:",
+  "  --key <value>              (direct, visible in history)",
+  "  --key-stdin                (pipe from stdin)",
+  "  --key-file <path>          (read from file)",
+  `  ${ENV_API_KEY}=<value>    (environment variable)`,
+  "",
+  "On POSIX TTYs an interactive hidden prompt is also available.",
+  "See: memrosetta sync enable --help"
+].join("\n");
+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" || first === "backfill") {
+    return first;
+  }
+  return null;
+}
+var CONTROL_CHAR_REGEX = /[\x00-\x1F\x7F]/;
+function validateApiKey(key, sourceLabel) {
+  const trimmed = key.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`API key from ${sourceLabel} is empty.`);
+  }
+  if (CONTROL_CHAR_REGEX.test(trimmed)) {
+    throw new Error(
+      `API key from ${sourceLabel} contains control characters. Try --key-file or MEMROSETTA_SYNC_API_KEY instead.`
+    );
+  }
+  return trimmed;
+}
+function readKeyFile(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Could not read --key-file '${path}': ${msg}`);
+  }
+}
+async function resolveApiKey(args) {
+  const directKey = optionalOption(args, "--key");
+  const keyFile = optionalOption(args, "--key-file");
+  const useStdin = hasFlag(args, "--key-stdin");
+  const explicitCount = [directKey !== void 0, keyFile !== void 0, useStdin].filter(Boolean).length;
+  if (explicitCount > 1) {
+    throw new Error(
+      "Specify only one of --key, --key-stdin, --key-file."
+    );
+  }
+  if (directKey !== void 0) {
+    return validateApiKey(directKey, "--key");
+  }
+  if (useStdin) {
+    const raw = await readStdinKey();
+    if (!raw) {
+      throw new Error(
+        "--key-stdin produced no input. On Windows PowerShell, prefer --key-file or MEMROSETTA_SYNC_API_KEY."
+      );
+    }
+    return validateApiKey(raw, "--key-stdin");
+  }
+  if (keyFile !== void 0) {
+    return validateApiKey(readKeyFile(keyFile), `--key-file ${keyFile}`);
+  }
+  const envKey = process.env[ENV_API_KEY];
+  if (envKey !== void 0 && envKey.length > 0) {
+    return validateApiKey(envKey, ENV_API_KEY);
+  }
+  if (platform() !== "win32" && process.stdin.isTTY) {
+    const raw = await readHiddenInput("API key: ");
+    return validateApiKey(raw, "hidden prompt");
+  }
+  throw new Error(KEY_SOURCE_HINT);
+}
+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 originalWrite = stdout.write.bind(stdout);
+  let muted = true;
+  stdout.write = (chunk, ...rest) => {
+    if (!muted) {
+      return originalWrite(chunk, ...rest);
+    }
+    const str = typeof chunk === "string" ? chunk : chunk?.toString?.("utf-8") ?? "";
+    if (str === "\n" || str === "\r\n" || str === "\r") {
+      return originalWrite(chunk, ...rest);
+    }
+    return true;
+  };
+  const rl = createInterface({
+    input: stdin,
+    output: stdout,
+    terminal: true
+  });
+  try {
+    const answer = await new Promise((resolve, reject) => {
+      rl.once("close", () => {
+        reject(new Error("Aborted"));
+      });
+      rl.question("", (value) => {
+        resolve(value);
+      });
+    });
+    return answer;
+  } finally {
+    muted = false;
+    stdout.write = originalWrite;
+    rl.close();
+  }
+}
+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>");
+  }
+  if (CONTROL_CHAR_REGEX.test(config.syncApiKey)) {
+    throw new Error(
+      `Stored API key is invalid (contains control characters from a previous terminal input). Re-run with one of:
+  memrosetta sync enable --server ${config.syncServerUrl} --key <api-key>
+  memrosetta sync enable --server ${config.syncServerUrl} --key-file path/to/key
+  $env:${ENV_API_KEY}='<api-key>'; memrosetta sync enable --server ${config.syncServerUrl}`
+    );
+  }
+  const db = new Database(dbPath);
+  try {
+    ensureSyncSchema(db);
+    const client = new SyncClient(db, {
+      serverUrl: config.syncServerUrl,
+      apiKey: config.syncApiKey,
+      deviceId: config.syncDeviceId,
+      userId: config.syncUserId ?? 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;
+  try {
+    apiKey = await resolveApiKey(args);
+  } catch (err) {
+    outputError(err instanceof Error ? err.message : String(err), 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)}`;
+  const userOverride = optionalOption(args, "--user");
+  const syncUserId = userOverride ?? existing.syncUserId ?? userInfo().username;
+  writeConfig({
+    ...existing,
+    syncEnabled: true,
+    syncServerUrl: serverUrl,
+    syncApiKey: apiKey,
+    syncDeviceId: deviceId,
+    syncUserId
+  });
+  if (format === "text") {
+    process.stdout.write("Sync enabled.\n");
+    process.stdout.write(`  Server:   ${serverUrl}
+`);
+    process.stdout.write(`  UserId:   ${syncUserId}
+`);
+    process.stdout.write(`  DeviceId: ${deviceId}
+`);
+    if (skipTest) {
+      process.stdout.write("  (health check skipped)\n");
+    }
+    return;
+  }
+  output(
+    { enabled: true, serverUrl, userId: syncUserId, 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.syncUserId) {
+        process.stdout.write(`  UserId:   ${config.syncUserId}
+`);
+      }
+      if (config.syncDeviceId) {
+        process.stdout.write(`  DeviceId: ${config.syncDeviceId}
+`);
+      }
+      return;
+    }
+    output(
+      {
+        enabled: false,
+        serverUrl: config.syncServerUrl ?? null,
+        userId: config.syncUserId ?? 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(`  UserId:          ${status.userId}
+`);
+      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 runBackfill(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 dryRun = hasFlag(args, "--dry-run");
+  const userFilter = optionalOption(args, "--user");
+  const namespaceFilter = optionalOption(args, "--namespace");
+  const includeRelations = !hasFlag(args, "--memories-only");
+  const sync = await openCliSyncContext(dbPath);
+  if (!sync.enabled) {
+    outputError("Sync is not fully configured. Run: memrosetta sync enable", format);
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const { default: Database } = await import("better-sqlite3");
+    const readDb = new Database(dbPath, { readonly: true });
+    try {
+      const params = [];
+      let where = "1=1";
+      if (userFilter) {
+        where += " AND user_id = ?";
+        params.push(userFilter);
+      }
+      if (namespaceFilter) {
+        where += " AND namespace = ?";
+        params.push(namespaceFilter);
+      }
+      const memRows = readDb.prepare(
+        `SELECT memory_id, user_id, namespace, memory_type, content, raw_text,
+                  document_date, source_id, confidence, salience, keywords,
+                  event_date_start, event_date_end, invalidated_at, learned_at
+           FROM memories
+           WHERE ${where}`
+      ).all(...params);
+      let memoriesQueued = 0;
+      let relationsQueued = 0;
+      const memoryIdSet = /* @__PURE__ */ new Set();
+      for (const row of memRows) {
+        memoryIdSet.add(row.memory_id);
+        if (dryRun) continue;
+        const op = {
+          opId: deterministicOpId("memory_created", row.memory_id),
+          opType: "memory_created",
+          deviceId: sync.deviceId,
+          userId: sync.userId,
+          createdAt: row.learned_at,
+          payload: {
+            memoryId: row.memory_id,
+            userId: row.user_id,
+            namespace: row.namespace ?? void 0,
+            memoryType: row.memory_type,
+            content: row.content,
+            rawText: row.raw_text ?? void 0,
+            documentDate: row.document_date ?? void 0,
+            sourceId: row.source_id ?? void 0,
+            confidence: row.confidence,
+            salience: row.salience,
+            // core stores keywords as a space-joined string, not JSON.
+            keywords: row.keywords ? row.keywords.split(" ").filter((k) => k.length > 0) : void 0,
+            eventDateStart: row.event_date_start ?? void 0,
+            eventDateEnd: row.event_date_end ?? void 0,
+            invalidatedAt: row.invalidated_at ?? void 0,
+            learnedAt: row.learned_at
+          }
+        };
+        sync.enqueue(op);
+        memoriesQueued++;
+      }
+      if (dryRun) memoriesQueued = memRows.length;
+      if (includeRelations) {
+        const relRows = readDb.prepare(
+          "SELECT src_memory_id, dst_memory_id, relation_type, created_at, reason FROM memory_relations"
+        ).all();
+        for (const row of relRows) {
+          if (!memoryIdSet.has(row.src_memory_id) || !memoryIdSet.has(row.dst_memory_id)) {
+            continue;
+          }
+          if (!dryRun) {
+            const relKey = `${row.src_memory_id}|${row.dst_memory_id}|${row.relation_type}`;
+            const op = {
+              opId: deterministicOpId("relation_created", relKey),
+              opType: "relation_created",
+              deviceId: sync.deviceId,
+              userId: sync.userId,
+              createdAt: row.created_at,
+              payload: {
+                srcMemoryId: row.src_memory_id,
+                dstMemoryId: row.dst_memory_id,
+                relationType: row.relation_type,
+                createdAt: row.created_at,
+                reason: row.reason ?? void 0
+              }
+            };
+            sync.enqueue(op);
+          }
+          relationsQueued++;
+        }
+      }
+      const result = {
+        memoriesQueued,
+        relationsQueued,
+        dryRun,
+        userFilter: userFilter ?? null,
+        namespaceFilter: namespaceFilter ?? null
+      };
+      if (format === "text") {
+        process.stdout.write(
+          `${dryRun ? "Dry run: would enqueue" : "Enqueued"} ${memoriesQueued} memories` + (includeRelations ? ` and ${relationsQueued} relations` : "") + ".\n"
+        );
+        if (userFilter || namespaceFilter) {
+          process.stdout.write(
+            `  Filters: user=${userFilter ?? "*"} namespace=${namespaceFilter ?? "*"}
+`
+          );
+        }
+        if (!dryRun) {
+          process.stdout.write("Run `memrosetta sync now` to push to the server.\n");
+        }
+        return;
+      }
+      output(result, format);
+    } finally {
+      readDb.close();
+    }
+  } finally {
+    sync.close();
+  }
+}
+async function run(options) {
+  const sub = parseSubcommand(options.args);
+  if (!sub) {
+    outputError(
+      "Usage: memrosetta sync <enable|disable|status|now|device-id|backfill>\n\n  enable    --server <url> [--key <key> | --key-stdin | --key-file <p>]\n  disable\n  status\n  now       [--push-only | --pull-only]\n  device-id\n  backfill  [--user <id>] [--namespace <ns>] [--memories-only] [--dry-run]\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;
+    case "backfill":
+      await runBackfill(rest);
+      return;
+  }
+}
+export {
+  run
+};

package/dist/working-memory-CH524PJA.js

@@ -0,0 +1,53 @@
+import {
+  optionalOption
+} from "./chunk-SYPVELIW.js";
+import {
+  getEngine
+} from "./chunk-VAVUPQZA.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/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@memrosetta/cli",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
     "memrosetta": "./dist/index.js",
     "memrosetta-on-stop": "./dist/hooks/on-stop.js",
-    "memrosetta-on-prompt": "./dist/hooks/on-prompt.js"
+    "memrosetta-on-prompt": "./dist/hooks/on-prompt.js",
+    "memrosetta-enforce-claude-code": "./dist/hooks/enforce-claude-code.js"
   },
   "files": [
     "dist",
@@ -15,10 +16,10 @@
   ],
   "dependencies": {
     "better-sqlite3": "^11.0.0",
-    "@memrosetta/types": "0.4.0",
+    "@memrosetta/core": "0.4.0",
     "@memrosetta/embeddings": "0.3.0",
-    "@memrosetta/sync-client": "0.1.4",
-    "@memrosetta/core": "0.4.0"
+    "@memrosetta/types": "0.4.0",
+    "@memrosetta/sync-client": "0.1.5"
   },
   "optionalDependencies": {
     "@memrosetta/llm": "0.3.0"
@@ -30,7 +31,7 @@
     "vitest": "^2.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/hooks/on-stop.ts src/hooks/on-prompt.ts --format esm --external better-sqlite3 --external @memrosetta/core --external @memrosetta/embeddings --external @memrosetta/sync-client --external @memrosetta/types --external @memrosetta/llm --external @huggingface/transformers --external sqlite-vec --external onnxruntime-node",
+    "build": "tsup src/index.ts src/hooks/on-stop.ts src/hooks/on-prompt.ts src/hooks/enforce-claude-code.ts --format esm --external better-sqlite3 --external @memrosetta/core --external @memrosetta/embeddings --external @memrosetta/sync-client --external @memrosetta/types --external @memrosetta/llm --external @memrosetta/extractor --external @huggingface/transformers --external sqlite-vec --external onnxruntime-node",
     "start": "node dist/index.js",
     "test": "vitest run",
     "test:watch": "vitest",