@memrosetta/cli 0.4.2 → 0.4.4

package/dist/chunk-YXK6FDB6.js

@@ -0,0 +1,42 @@
+// src/version.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+function resolveCliVersion() {
+  const strategies = [
+    () => {
+      const require2 = createRequire(import.meta.url);
+      return require2("../../package.json").version;
+    },
+    () => {
+      const require2 = createRequire(import.meta.url);
+      return require2("@memrosetta/cli/package.json").version;
+    },
+    () => {
+      const dir = dirname(fileURLToPath(import.meta.url));
+      for (let d = dir, i = 0; i < 5; i++) {
+        const candidate = join(d, "package.json");
+        if (existsSync(candidate)) {
+          const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+          if (pkg.name?.includes("memrosetta") && pkg.version) {
+            return pkg.version;
+          }
+        }
+        d = dirname(d);
+      }
+      throw new Error("not found");
+    }
+  ];
+  for (const strategy of strategies) {
+    try {
+      return strategy();
+    } catch {
+    }
+  }
+  return "unknown";
+}
+
+export {
+  resolveCliVersion
+};

package/dist/index.js

@@ -56,12 +56,16 @@ Global Options:
   --version, -v       Show version
 
 Sync Subcommands:
-  memrosetta sync enable --server <url>    # Enable sync, hidden API key prompt
-  memrosetta sync enable --server <url> --key-stdin   # Read API key from stdin
-  memrosetta sync disable                  # Disable sync (keeps server/key)
+  memrosetta sync enable --server <url> [key-source]
+    Key sources (mutually exclusive, exactly one):
+      --key <value>             Direct (visible in shell history)
+      --key-stdin               Read from stdin (echo key | memrosetta ...)
+      --key-file <path>         Read from file
+      MEMROSETTA_SYNC_API_KEY   Environment variable (fallback)
+      (no flag)                 POSIX TTY only: hidden prompt
+  memrosetta sync disable                  # Disable (keeps server/key)
   memrosetta sync status                   # Show sync state + pending ops
-  memrosetta sync now                      # Push + pull now
-  memrosetta sync now --push-only          # Push only
+  memrosetta sync now [--push-only | --pull-only]
   memrosetta sync device-id                # Print current device id
 
 Examples:
@@ -165,7 +169,7 @@ async function main() {
         break;
       }
       case "status": {
-        const mod = await import("./status-TVY32MZD.js");
+        const mod = await import("./status-HLKL32NP.js");
         await mod.run(commandOptions);
         break;
       }
@@ -180,12 +184,12 @@ async function main() {
         break;
       }
       case "update": {
-        const mod = await import("./update-M74FBMYN.js");
+        const mod = await import("./update-4F3YY2HU.js");
         await mod.run();
         break;
       }
       case "sync": {
-        const mod = await import("./sync-7TONPJBY.js");
+        const mod = await import("./sync-GMGC66NK.js");
         await mod.run(commandOptions);
         break;
       }

package/dist/status-HLKL32NP.js

@@ -0,0 +1,184 @@
+import {
+  isClaudeCodeConfigured,
+  isCodexConfigured,
+  isCursorConfigured,
+  isGeminiConfigured,
+  isGenericMCPConfigured
+} from "./chunk-IS4IKWPL.js";
+import {
+  resolveCliVersion
+} from "./chunk-YXK6FDB6.js";
+import {
+  getDefaultDbPath
+} from "./chunk-72IW6TAV.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getConfig
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/status.ts
+import { existsSync, statSync } from "fs";
+async function run(options) {
+  const { format, db, noEmbeddings } = options;
+  const config = getConfig();
+  const dbPath = db ?? config.dbPath ?? getDefaultDbPath();
+  const exists = existsSync(dbPath);
+  let sizeBytes = 0;
+  let sizeFormatted = "0B";
+  let memoryCount = 0;
+  let userList = [];
+  let qualityFresh = 0;
+  let qualityInvalidated = 0;
+  let qualityWithRelations = 0;
+  let qualityAvgActivation = 0;
+  const embeddingsEnabled = !noEmbeddings && config.enableEmbeddings !== false;
+  if (exists) {
+    const stat = statSync(dbPath);
+    sizeBytes = stat.size;
+    sizeFormatted = formatSize(sizeBytes);
+    try {
+      const Database = (await import("better-sqlite3")).default;
+      const dbConn = new Database(dbPath);
+      dbConn.pragma("journal_mode = WAL");
+      const countRow = dbConn.prepare("SELECT COUNT(*) as count FROM memories").get();
+      memoryCount = countRow.count;
+      const userRows = dbConn.prepare("SELECT DISTINCT user_id FROM memories ORDER BY user_id").all();
+      userList = userRows.map((r) => r.user_id);
+      const freshRow = dbConn.prepare(
+        "SELECT COUNT(*) as c FROM memories WHERE is_latest = 1 AND invalidated_at IS NULL"
+      ).get();
+      qualityFresh = freshRow.c;
+      const invalidatedRow = dbConn.prepare(
+        "SELECT COUNT(*) as c FROM memories WHERE invalidated_at IS NOT NULL"
+      ).get();
+      qualityInvalidated = invalidatedRow.c;
+      const relationsRow = dbConn.prepare(
+        "SELECT COUNT(DISTINCT src_memory_id) + COUNT(DISTINCT dst_memory_id) as c FROM memory_relations"
+      ).get();
+      qualityWithRelations = relationsRow.c;
+      const avgRow = dbConn.prepare(
+        "SELECT AVG(activation_score) as avg FROM memories WHERE is_latest = 1"
+      ).get();
+      qualityAvgActivation = avgRow.avg ?? 0;
+      dbConn.close();
+    } catch {
+    }
+  }
+  const claudeCodeStatus = isClaudeCodeConfigured();
+  const cursorStatus = isCursorConfigured();
+  const codexStatus = isCodexConfigured();
+  const geminiStatus = isGeminiConfigured();
+  const mcpStatus = isGenericMCPConfigured();
+  if (format === "text") {
+    process.stdout.write("MemRosetta Status\n");
+    process.stdout.write(`${"=".repeat(40)}
+
+`);
+    process.stdout.write(
+      `Database: ${dbPath} (${exists ? `exists, ${sizeFormatted}` : "not found"})
+`
+    );
+    process.stdout.write(`Memories: ${memoryCount}
+`);
+    if (userList.length > 0) {
+      process.stdout.write(
+        `Users: ${userList.length} (${userList.join(", ")})
+`
+      );
+    } else {
+      process.stdout.write("Users: 0\n");
+    }
+    const embeddingModelLabel = getEmbeddingModelLabel();
+    process.stdout.write(
+      `Embeddings: ${embeddingsEnabled ? `enabled (${embeddingModelLabel})` : "disabled"}
+`
+    );
+    if (memoryCount > 0) {
+      process.stdout.write("\nQuality:\n");
+      process.stdout.write(
+        `  Fresh (is_latest=1):    ${qualityFresh} / ${memoryCount}
+`
+      );
+      process.stdout.write(`  Invalidated:            ${qualityInvalidated}
+`);
+      process.stdout.write(`  With relations:         ${qualityWithRelations}
+`);
+      process.stdout.write(
+        `  Avg activation:         ${qualityAvgActivation.toFixed(2)}
+`
+      );
+    }
+    process.stdout.write("\nIntegrations:\n");
+    process.stdout.write(
+      `  Claude Code:   ${claudeCodeStatus ? "configured (hooks + MCP)" : "not configured"}
+`
+    );
+    process.stdout.write(
+      `  Cursor:        ${cursorStatus ? "configured (MCP)" : "not configured"}
+`
+    );
+    process.stdout.write(
+      `  Codex:         ${codexStatus ? "configured (MCP)" : "not configured"}
+`
+    );
+    process.stdout.write(
+      `  Gemini:        ${geminiStatus ? "configured (MCP)" : "not configured"}
+`
+    );
+    process.stdout.write(
+      `  MCP (generic): ${mcpStatus ? "configured" : "not configured"}
+`
+    );
+    return;
+  }
+  output(
+    {
+      version: resolveCliVersion(),
+      database: {
+        path: dbPath,
+        exists,
+        sizeBytes,
+        sizeFormatted
+      },
+      memories: memoryCount,
+      users: userList,
+      quality: {
+        fresh: qualityFresh,
+        invalidated: qualityInvalidated,
+        withRelations: qualityWithRelations,
+        avgActivation: qualityAvgActivation
+      },
+      embeddings: embeddingsEnabled,
+      embeddingModel: getEmbeddingModelLabel(),
+      embeddingPreset: getConfig().embeddingPreset ?? "en",
+      integrations: {
+        claudeCode: claudeCodeStatus,
+        cursor: cursorStatus,
+        codex: codexStatus,
+        gemini: geminiStatus,
+        mcp: mcpStatus
+      }
+    },
+    format
+  );
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+var PRESET_MODEL_LABELS = {
+  en: "bge-small-en-v1.5",
+  multilingual: "multilingual-e5-small",
+  ko: "ko-sroberta-multitask"
+};
+function getEmbeddingModelLabel() {
+  const config = getConfig();
+  const preset = config.embeddingPreset ?? "en";
+  return PRESET_MODEL_LABELS[preset] ?? preset;
+}
+export {
+  run
+};

package/dist/sync-GMGC66NK.js

@@ -0,0 +1,386 @@
+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 { 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") {
+    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: 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)}`;
+  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-4F3YY2HU.js

@@ -0,0 +1,79 @@
+import {
+  resolveCliVersion
+} from "./chunk-YXK6FDB6.js";
+
+// src/commands/update.ts
+import { execSync } from "child_process";
+function parseNpmList(raw) {
+  const start = raw.indexOf("{");
+  if (start === -1) return {};
+  try {
+    return JSON.parse(raw.slice(start));
+  } catch {
+    return {};
+  }
+}
+function getInstalledVersion(packageName) {
+  try {
+    const raw = execSync(`npm list -g ${packageName} --depth=0 --json`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const parsed = parseNpmList(raw);
+    const deps = parsed.dependencies ?? {};
+    return deps[packageName]?.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function run() {
+  const runningVersion = resolveCliVersion();
+  const wrapperInstalled = getInstalledVersion("memrosetta");
+  const cliInstalled = getInstalledVersion("@memrosetta/cli");
+  let packageName;
+  let currentVersion;
+  if (wrapperInstalled) {
+    packageName = "memrosetta";
+    currentVersion = wrapperInstalled;
+  } else if (cliInstalled) {
+    packageName = "@memrosetta/cli";
+    currentVersion = cliInstalled;
+  } else {
+    packageName = "memrosetta";
+    currentVersion = runningVersion;
+  }
+  process.stdout.write(`Current version: ${currentVersion} (${packageName})
+`);
+  if (currentVersion !== runningVersion && runningVersion !== "unknown") {
+    process.stdout.write(`Running binary:   ${runningVersion}
+`);
+  }
+  process.stdout.write("Checking for updates...\n");
+  try {
+    const latest = execSync(`npm view ${packageName} version`, {
+      encoding: "utf-8"
+    }).trim();
+    if (latest === currentVersion) {
+      process.stdout.write(`Already up to date (${currentVersion}).
+`);
+      return;
+    }
+    process.stdout.write(`New version available: ${latest}
+`);
+    process.stdout.write("Updating...\n");
+    execSync(`npm install -g ${packageName}@latest --force`, {
+      stdio: "inherit"
+    });
+    process.stdout.write(`
+Updated: ${currentVersion} -> ${latest}
+`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`Update failed: ${message}
+`);
+    process.exitCode = 1;
+  }
+}
+export {
+  run
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memrosetta/cli",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {