unforgit 0.1.0 → 0.3.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command28 } from "commander";
+import { Command as Command29 } from "commander";
 
 // src/commands/init.ts
 import fs2 from "fs";
@@ -156,46 +156,66 @@ Trigger a save with the \`unforgit_add\` tool immediately after:
 - Do NOT save trivial changes, obvious things, or info already in the codebase docs
 - Quality over quantity \u2014 only save what's genuinely useful for future sessions
 - **Always write memory text in English**, regardless of the language the user is speaking`;
-function fileContainsUnforgit(filePath) {
-  if (!fs.existsSync(filePath)) return false;
-  return fs.readFileSync(filePath, "utf-8").includes(UNFORGIT_MARKER);
-}
 function upsertJsonMcp(filePath, serverKey, mcpEntry) {
   const dir = path.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true });
-  if (!fs.existsSync(filePath)) {
-    const config = { [serverKey]: { unforgit: mcpEntry } };
-    fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-    return { path: filePath, action: "created" };
-  }
-  const existing = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-  const servers = existing[serverKey];
-  if (servers?.unforgit) {
-    return { path: filePath, action: "exists" };
-  }
-  existing[serverKey] = existing[serverKey] || {};
-  existing[serverKey].unforgit = mcpEntry;
-  fs.writeFileSync(
-    filePath,
-    JSON.stringify(existing, null, 2) + "\n",
-    "utf-8"
-  );
-  return { path: filePath, action: "updated" };
+  const fd = fs.openSync(filePath, "a+");
+  try {
+    const raw = fs.readFileSync(fd, "utf-8");
+    if (raw.trim().length === 0) {
+      const config = { [serverKey]: { unforgit: mcpEntry } };
+      fs.writeSync(fd, JSON.stringify(config, null, 2) + "\n", 0, "utf-8");
+      return { path: filePath, action: "created" };
+    }
+    const existing = JSON.parse(raw);
+    const servers = existing[serverKey];
+    if (servers?.unforgit) {
+      return { path: filePath, action: "exists" };
+    }
+    existing[serverKey] = existing[serverKey] || {};
+    existing[serverKey].unforgit = mcpEntry;
+    fs.ftruncateSync(fd, 0);
+    fs.writeSync(fd, JSON.stringify(existing, null, 2) + "\n", 0, "utf-8");
+    return { path: filePath, action: "updated" };
+  } finally {
+    fs.closeSync(fd);
+  }
 }
 function appendOrCreateMarkdown(filePath, content) {
   const dir = path.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true });
-  if (!fs.existsSync(filePath)) {
-    fs.writeFileSync(filePath, content + "\n", "utf-8");
-    return { path: filePath, action: "created" };
+  const fd = fs.openSync(filePath, "a+");
+  try {
+    const existing = fs.readFileSync(fd, "utf-8");
+    if (existing.length === 0) {
+      fs.writeSync(fd, content + "\n", 0, "utf-8");
+      return { path: filePath, action: "created" };
+    }
+    if (existing.includes(UNFORGIT_MARKER)) {
+      return { path: filePath, action: "exists" };
+    }
+    const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+    fs.writeSync(fd, separator + content + "\n", void 0, "utf-8");
+    return { path: filePath, action: "updated" };
+  } finally {
+    fs.closeSync(fd);
   }
-  if (fileContainsUnforgit(filePath)) {
-    return { path: filePath, action: "exists" };
+}
+function replaceMarkdownIfMissingMarker(filePath, content) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const fd = fs.openSync(filePath, "a+");
+  try {
+    const existing = fs.readFileSync(fd, "utf-8");
+    if (existing.includes(UNFORGIT_MARKER)) {
+      return { path: filePath, action: "exists" };
+    }
+    fs.ftruncateSync(fd, 0);
+    fs.writeSync(fd, content, 0, "utf-8");
+    return { path: filePath, action: existing.length === 0 ? "created" : "updated" };
+  } finally {
+    fs.closeSync(fd);
   }
-  const existing = fs.readFileSync(filePath, "utf-8");
-  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-  fs.writeFileSync(filePath, existing + separator + content + "\n", "utf-8");
-  return { path: filePath, action: "updated" };
 }
 var CURSOR_RULE_CONTENT = `---
 description: Auto-manage repository memory with Unforgit via MCP tools
@@ -207,14 +227,7 @@ ${MEMORY_INSTRUCTIONS}
 function setupCursor(cwd4) {
   const rulesDir = path.join(cwd4, ".cursor", "rules");
   const rulePath = path.join(rulesDir, "unforgit-memory.mdc");
-  let rules;
-  if (fileContainsUnforgit(rulePath)) {
-    rules = { path: rulePath, action: "exists" };
-  } else {
-    fs.mkdirSync(rulesDir, { recursive: true });
-    fs.writeFileSync(rulePath, CURSOR_RULE_CONTENT, "utf-8");
-    rules = { path: rulePath, action: "created" };
-  }
+  const rules = replaceMarkdownIfMissingMarker(rulePath, CURSOR_RULE_CONTENT);
   const mcpPath = path.join(cwd4, ".cursor", "mcp.json");
   const mcp = upsertJsonMcp(mcpPath, "mcpServers", {
     command: "unforgit-mcp",
@@ -2895,16 +2908,133 @@ embeddingsCommand.command("clear").description("Remove all embeddings (requires
 });
 
 // src/commands/reset.ts
-import { Command as Command24 } from "commander";
-import { loadConfig as loadConfig21, getDbPath as getDbPath18 } from "unforgit-config";
+import { Command as Command25 } from "commander";
+import { loadConfig as loadConfig21, getDbPath as getDbPath19 } from "unforgit-config";
 import { LocalStore as LocalStore18 } from "unforgit-db";
 import { RemoteClient as RemoteClient12 } from "unforgit-config";
-var resetCommand = new Command24("reset").description("Permanently delete all memories and related data").option("--local", "Reset local store only").option("--remote", "Reset remote store only").option("--force", "Skip confirmation prompt").addHelpText("after", `
+
+// src/commands/backups.ts
+import fs4 from "fs";
+import path3 from "path";
+import { Command as Command24 } from "commander";
+import { getDbPath as getDbPath18 } from "unforgit-config";
+function formatBackupTimestamp(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace("T", "-").replace(/\.\d{3}Z$/, "");
+}
+function backupRootForDb(dbPath) {
+  return path3.join(path3.dirname(dbPath), "backups");
+}
+function describeBackup(dir) {
+  const files = fs4.readdirSync(dir).filter((file) => file === "local.db" || file === "local.db-wal" || file === "local.db-shm").sort();
+  const sizeBytes = files.reduce((total, file) => total + fs4.statSync(path3.join(dir, file)).size, 0);
+  const stat = fs4.statSync(dir);
+  return {
+    name: path3.basename(dir),
+    dir,
+    files,
+    sizeBytes,
+    createdAt: stat.mtime.toISOString()
+  };
+}
+function resolveBackupDir(backupRoot, backupName) {
+  if (backupName !== path3.basename(backupName)) {
+    throw new Error("Invalid backup name");
+  }
+  const resolvedRoot = path3.resolve(backupRoot);
+  const resolvedBackup = path3.resolve(resolvedRoot, backupName);
+  if (!resolvedBackup.startsWith(`${resolvedRoot}${path3.sep}`)) {
+    throw new Error("Invalid backup name");
+  }
+  return resolvedBackup;
+}
+function createLocalResetBackup(dbPath, now = /* @__PURE__ */ new Date()) {
+  if (!fs4.existsSync(dbPath)) {
+    return null;
+  }
+  const backupRoot = backupRootForDb(dbPath);
+  const baseName = `reset-${formatBackupTimestamp(now)}`;
+  let backupDir = path3.join(backupRoot, baseName);
+  let suffix = 1;
+  while (fs4.existsSync(backupDir)) {
+    backupDir = path3.join(backupRoot, `${baseName}-${suffix++}`);
+  }
+  fs4.mkdirSync(backupDir, { recursive: true, mode: 448 });
+  for (const source of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+    if (!fs4.existsSync(source)) continue;
+    fs4.copyFileSync(source, path3.join(backupDir, path3.basename(source)));
+  }
+  return describeBackup(backupDir);
+}
+function listLocalResetBackups(dbPath) {
+  const backupRoot = backupRootForDb(dbPath);
+  if (!fs4.existsSync(backupRoot)) {
+    return [];
+  }
+  return fs4.readdirSync(backupRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("reset-")).map((entry) => describeBackup(path3.join(backupRoot, entry.name))).filter((backup) => backup.files.includes("local.db")).sort((a, b) => b.name.localeCompare(a.name));
+}
+function restoreLocalResetBackup(dbPath, backupName, now = /* @__PURE__ */ new Date()) {
+  const backupRoot = backupRootForDb(dbPath);
+  const backupDir = resolveBackupDir(backupRoot, backupName);
+  if (!fs4.existsSync(backupDir) || !fs4.statSync(backupDir).isDirectory()) {
+    throw new Error(`Backup not found: ${backupName}`);
+  }
+  const restoredFrom = describeBackup(backupDir);
+  if (!restoredFrom.files.includes("local.db")) {
+    throw new Error(`Backup is missing local.db: ${backupName}`);
+  }
+  const safetyBackup = createLocalResetBackup(dbPath, now);
+  fs4.mkdirSync(path3.dirname(dbPath), { recursive: true });
+  for (const target of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+    if (fs4.existsSync(target)) {
+      fs4.rmSync(target, { force: true });
+    }
+  }
+  for (const file of restoredFrom.files) {
+    fs4.copyFileSync(path3.join(backupDir, file), path3.join(path3.dirname(dbPath), file));
+  }
+  return { restoredFrom, safetyBackup };
+}
+var backupsCommand = new Command24("backups").description("List and restore local reset backups");
+backupsCommand.command("list").description("List local backups created before destructive resets/restores").action(() => {
+  const backups = listLocalResetBackups(getDbPath18());
+  if (backups.length === 0) {
+    logger.info("No local reset backups found.");
+    return;
+  }
+  for (const backup of backups) {
+    logger.info(`${backup.name}	${backup.sizeBytes} bytes	${backup.dir}`);
+  }
+});
+backupsCommand.command("restore").argument("<name>", "Backup directory name, for example reset-20260610-123456").description("Restore a local reset backup into the active local database").option("--force", "Skip confirmation prompt").action(async (name, opts) => {
+  if (!opts.force) {
+    const ok = await confirm(
+      "This will replace the active local database after creating a safety backup. Continue?"
+    );
+    if (!ok) {
+      logger.info("Aborted.");
+      return;
+    }
+  }
+  try {
+    const result = restoreLocalResetBackup(getDbPath18(), name);
+    logger.info(`Restored local database from ${result.restoredFrom.name}`);
+    if (result.safetyBackup) {
+      logger.info(`Previous local database safety backup: ${result.safetyBackup.dir}`);
+    }
+  } catch (err) {
+    logger.error(err instanceof Error ? err.message : String(err));
+    process.exit(EXIT_ERROR);
+  }
+});
+
+// src/commands/reset.ts
+var resetCommand = new Command25("reset").description("Permanently delete all memories and related data").option("--local", "Reset local store only").option("--remote", "Reset remote store only").option("--force", "Skip confirmation prompt").option("--no-backup", "Skip automatic local database backup before local reset").addHelpText("after", `
 Examples:
   unforgit reset                Reset both local and remote
   unforgit reset --local        Reset local store only
   unforgit reset --remote       Reset remote store only
-  unforgit reset --force        Skip confirmation`).action(async (opts) => {
+  unforgit reset --force        Skip confirmation
+  unforgit reset --no-backup    Skip local backup before reset`).action(async (opts) => {
   const resetLocal = opts.local || !opts.local && !opts.remote;
   const resetRemote = opts.remote || !opts.local && !opts.remote;
   const targets = [
@@ -2924,7 +3054,21 @@ Examples:
   }
   const config = loadConfig21();
   if (resetLocal) {
-    const store = new LocalStore18(getDbPath18());
+    const dbPath = getDbPath19();
+    if (opts.backup !== false) {
+      try {
+        const backup = createLocalResetBackup(dbPath);
+        if (backup) {
+          logger.info(`Created local reset backup: ${backup.dir}`);
+        }
+      } catch (err) {
+        logger.error(
+          `Failed to create local reset backup: ${err instanceof Error ? err.message : String(err)}`
+        );
+        process.exit(EXIT_ERROR);
+      }
+    }
+    const store = new LocalStore18(dbPath);
     try {
       const result = store.resetAll();
       logger.info(`Local reset complete:`);
@@ -2965,22 +3109,24 @@ Examples:
 });
 
 // src/commands/doctor.ts
-import { Command as Command25 } from "commander";
-import { loadConfig as loadConfig22, getDbPath as getDbPath19, isInitialized as isInitialized16, getConfigPath as getConfigPath2 } from "unforgit-config";
+import { Command as Command26 } from "commander";
+import { loadConfig as loadConfig22, getDbPath as getDbPath20, isInitialized as isInitialized16, getConfigPath as getConfigPath2 } from "unforgit-config";
 import { LocalStore as LocalStore19 } from "unforgit-db";
 import { RemoteClient as RemoteClient13 } from "unforgit-config";
-import fs4 from "fs";
-var doctorCommand = new Command25("doctor").description("Check system health and diagnose common issues").action(async () => {
+import fs5 from "fs";
+import YAML from "yaml";
+var doctorCommand = new Command26("doctor").description("Check system health and diagnose common issues").action(async () => {
   const results = [];
   if (!isInitialized16()) {
     results.push({
       check: "initialization",
       status: "error",
-      message: "Not an unforgit repository. Run 'unforgit init' first."
+      message: "Not an unforgit repository. Run 'unforgit init' first.",
+      fix: "Run 'unforgit init' in the repository root."
     });
     if (isJsonMode()) {
-      outputJson({ results });
-      return;
+      outputJson(buildPayload(results));
+      process.exit(EXIT_CONFIG_ERROR);
     }
     printResults(results);
     process.exit(EXIT_CONFIG_ERROR);
@@ -2990,15 +3136,27 @@ var doctorCommand = new Command25("doctor").description("Check system health and
   try {
     const config = loadConfig22();
     results.push({ check: "config", status: "ok", message: `Valid config at ${configPath}` });
+    const deprecatedConfigKeys = findDeprecatedConfigKeys(configPath);
+    if (deprecatedConfigKeys.length > 0) {
+      results.push({
+        check: "config-deprecated-secrets",
+        status: "warn",
+        message: `Deprecated secret-bearing config key(s): ${deprecatedConfigKeys.join(", ")}`,
+        fix: "Move secrets to environment variables and remove them from unforgit.yaml."
+      });
+    } else {
+      results.push({ check: "config-deprecated-secrets", status: "ok", message: "No deprecated secret keys in config" });
+    }
     if (process.platform !== "win32") {
       try {
-        const stat = fs4.statSync(configPath);
+        const stat = fs5.statSync(configPath);
         const mode = stat.mode & 511;
         if (mode & 36) {
           results.push({
             check: "config-permissions",
             status: "warn",
-            message: `Config readable by others (mode ${mode.toString(8)}). Run: chmod 600 ${configPath}`
+            message: `Config readable by others (mode ${mode.toString(8)}). Run: chmod 600 ${configPath}`,
+            fix: `Run 'chmod 600 ${configPath}'.`
           });
         } else {
           results.push({ check: "config-permissions", status: "ok", message: "Config file permissions are secure" });
@@ -3007,12 +3165,18 @@ var doctorCommand = new Command25("doctor").description("Check system health and
         results.push({ check: "config-permissions", status: "warn", message: "Could not check config file permissions" });
       }
     }
-    const store = new LocalStore19(getDbPath19());
+    const store = new LocalStore19(getDbPath20());
     try {
       const orgId = config.remote.orgId || "local";
       const repoId = config.remote.repoId || "local";
       store.list({ orgId, repoId, limit: 1 });
       results.push({ check: "local-db", status: "ok", message: "SQLite database is accessible" });
+      const memoryStats = store.stats(orgId, repoId);
+      results.push({
+        check: "memory-stats",
+        status: "ok",
+        message: `${memoryStats.total} memories (${memoryStats.byType.episodic} episodic, ${memoryStats.byType.semantic} semantic, ${memoryStats.byType.procedural} procedural)`
+      });
       const stats = store.getEmbeddingStats(orgId, repoId);
       if (stats.total === 0) {
         results.push({ check: "embeddings", status: "ok", message: "No memories yet" });
@@ -3023,16 +3187,29 @@ var doctorCommand = new Command25("doctor").description("Check system health and
         results.push({
           check: "embeddings",
           status: "warn",
-          message: `${stats.withoutEmbedding}/${stats.total} memories lack embeddings (${pct}% coverage). Run 'unforgit embeddings backfill'`
+          message: `${stats.withoutEmbedding}/${stats.total} memories lack embeddings (${pct}% coverage). Run 'unforgit embeddings backfill'`,
+          fix: "Run 'unforgit embeddings backfill'."
         });
       }
       const pendingPush = store.getPendingPush();
       const conflicts = store.getConflicts();
+      const unsyncedTombstones = store.getUnsyncedTombstones(orgId, repoId);
+      if (unsyncedTombstones.length > 0) {
+        results.push({
+          check: "tombstones",
+          status: "warn",
+          message: `${unsyncedTombstones.length} deleted memory tombstone(s) pending sync`,
+          fix: "Run 'unforgit push' to sync deletions."
+        });
+      } else {
+        results.push({ check: "tombstones", status: "ok", message: "No deleted memory tombstones pending sync" });
+      }
       if (conflicts.length > 0) {
         results.push({
           check: "sync",
           status: "warn",
-          message: `${conflicts.length} sync conflict(s) need resolution`
+          message: `${conflicts.length} sync conflict(s) need resolution`,
+          fix: "Resolve conflicts with 'unforgit pull --force' or 'unforgit push --force' after reviewing the desired source of truth."
         });
       } else if (pendingPush.length > 0) {
         results.push({
@@ -3052,13 +3229,14 @@ var doctorCommand = new Command25("doctor").description("Check system health and
         results.push({
           check: "auth",
           status: "warn",
-          message: "No API key configured. Set the UNFORGIT_API_KEY environment variable."
+          message: "No API key configured. Set the UNFORGIT_API_KEY environment variable.",
+          fix: "Set UNFORGIT_API_KEY in your shell or secret manager before remote sync."
         });
       } else {
         results.push({
           check: "auth",
           status: "ok",
-          message: `API key configured: ${maskKey(apiKey)}`
+          message: "API key configured ([REDACTED])"
         });
       }
       try {
@@ -3071,58 +3249,107 @@ var doctorCommand = new Command25("doctor").description("Check system health and
               await client.listApiKeys();
               results.push({ check: "remote-auth", status: "ok", message: "API key is valid" });
             } catch {
-              results.push({ check: "remote-auth", status: "error", message: "API key is invalid or expired" });
+              results.push({
+                check: "remote-auth",
+                status: "error",
+                message: "API key is invalid or expired",
+                fix: "Create a new API key with 'unforgit keys create' or update UNFORGIT_API_KEY."
+              });
             }
           }
         } else {
           results.push({
             check: "remote",
             status: "error",
-            message: `Server returned HTTP ${res.status}`
+            message: `Server returned HTTP ${res.status}`,
+            fix: "Check the Unforgit API server health endpoint and remote.url in unforgit.yaml."
           });
         }
       } catch (err) {
         results.push({
           check: "remote",
           status: "error",
-          message: `Cannot connect to ${config.remote.url}: ${err instanceof Error ? err.message : err}`
+          message: `Cannot connect to ${config.remote.url}: ${err instanceof Error ? err.message : err}`,
+          fix: "Start the Unforgit API server or update remote.url in unforgit.yaml."
         });
       }
     } else {
-      results.push({ check: "remote", status: "warn", message: "No remote URL configured" });
+      results.push({
+        check: "remote",
+        status: "warn",
+        message: "No remote URL configured",
+        fix: "Run 'unforgit remote add origin <url>' if this repo should sync remotely."
+      });
     }
     const openaiKey = process.env.OPENAI_API_KEY;
     if (openaiKey) {
-      results.push({ check: "openai", status: "ok", message: `OpenAI API key configured: ${maskKey(openaiKey)}` });
+      results.push({ check: "openai", status: "ok", message: "OpenAI API key configured ([REDACTED])" });
     } else {
       results.push({
         check: "openai",
         status: "warn",
-        message: "No OpenAI API key. Auto-consolidation and embeddings backfill require it."
+        message: "No OpenAI API key. Auto-consolidation and embeddings backfill require it.",
+        fix: "Set OPENAI_API_KEY before running embedding backfill or AI consolidation."
       });
     }
   } catch (err) {
     results.push({
       check: "config",
       status: "error",
-      message: err instanceof Error ? err.message : String(err)
+      message: err instanceof Error ? err.message : String(err),
+      fix: `Fix ${configPath} or re-run 'unforgit init'.`
     });
   }
   if (isJsonMode()) {
-    outputJson({ results });
+    outputJson(buildPayload(results));
+    exitForResults(results);
     return;
   }
   printResults(results);
+  exitForResults(results);
 });
+function summarize(results) {
+  return {
+    ok: results.filter((r) => r.status === "ok").length,
+    warnings: results.filter((r) => r.status === "warn").length,
+    errors: results.filter((r) => r.status === "error").length
+  };
+}
+function buildPayload(results) {
+  return { summary: summarize(results), results };
+}
+function exitForResults(results) {
+  if (results.some((r) => r.status === "error")) {
+    process.exit(EXIT_ERROR);
+  }
+}
+function findDeprecatedConfigKeys(configPath) {
+  try {
+    const raw = fs5.readFileSync(configPath, "utf-8");
+    const parsed = YAML.parse(raw) ?? {};
+    const deprecated = [];
+    if (parsed.remote?.apiKey) {
+      deprecated.push("remote.apiKey");
+    }
+    if (parsed.openaiApiKey) {
+      deprecated.push("openaiApiKey");
+    }
+    return deprecated;
+  } catch {
+    return [];
+  }
+}
 function printResults(results) {
   const icons = { ok: "[ok]", warn: "[!!]", error: "[ERR]" };
   logger.info("Unforgit Doctor\n");
   for (const r of results) {
     const icon = icons[r.status];
     logger.info(`  ${icon} ${r.check}: ${r.message}`);
+    if (r.fix) {
+      logger.info(`       fix: ${r.fix}`);
+    }
   }
-  const errors = results.filter((r) => r.status === "error").length;
-  const warnings = results.filter((r) => r.status === "warn").length;
+  const { errors, warnings } = summarize(results);
   logger.info("");
   if (errors > 0) {
     logger.info(`${errors} error(s), ${warnings} warning(s)`);
@@ -3134,7 +3361,7 @@ function printResults(results) {
 }
 
 // src/commands/completion.ts
-import { Command as Command26 } from "commander";
+import { Command as Command27 } from "commander";
 var BASH_COMPLETION = `
 _unforgit_completions() {
   local cur prev commands
@@ -3279,7 +3506,7 @@ complete -c unforgit -l verbose -d 'Enable verbose output'
 complete -c unforgit -l quiet -d 'Suppress non-essential output'
 complete -c unforgit -l json -d 'Output as JSON'
 `.trim();
-var completionCommand = new Command26("completion").description("Generate shell completion scripts").argument("<shell>", "Shell type (bash, zsh, fish)").addHelpText("after", `
+var completionCommand = new Command27("completion").description("Generate shell completion scripts").argument("<shell>", "Shell type (bash, zsh, fish)").addHelpText("after", `
 Examples:
   unforgit completion bash >> ~/.bashrc
   unforgit completion zsh >> ~/.zshrc
@@ -3301,8 +3528,8 @@ Examples:
 });
 
 // src/commands/curate.ts
-import { Command as Command27 } from "commander";
-import { getDbPath as getDbPath20, isInitialized as isInitialized17, loadConfig as loadConfig23 } from "unforgit-config";
+import { Command as Command28 } from "commander";
+import { getDbPath as getDbPath21, isInitialized as isInitialized17, loadConfig as loadConfig23 } from "unforgit-config";
 import { LocalStore as LocalStore20 } from "unforgit-db";
 import { RemoteClient as RemoteClient14 } from "unforgit-config";
 import { runLocalLifecycleMaintenance } from "unforgit-core";
@@ -3318,7 +3545,7 @@ function formatCandidatePreview2(candidate) {
   }
   return lines.join("\n");
 }
-var curateCommand = new Command27("curate").description("Preview or run lifecycle maintenance for repository memories").option("--remote", "Run maintenance against the remote server").option("--execute", "Apply changes instead of previewing them").option("--model <model>", "OpenAI model to use for consolidation").option("--no-preserve", "Do not preserve original memories during consolidation").addHelpText("after", `
+var curateCommand = new Command28("curate").description("Preview or run lifecycle maintenance for repository memories").option("--remote", "Run maintenance against the remote server").option("--execute", "Apply changes instead of previewing them").option("--model <model>", "OpenAI model to use for consolidation").option("--no-preserve", "Do not preserve original memories during consolidation").addHelpText("after", `
 Examples:
   unforgit curate
   unforgit curate --execute
@@ -3338,7 +3565,7 @@ Examples:
       dryRun,
       model: opts.model,
       preserveOriginals: opts.preserve !== false
-    }) : await runLocalCurate(getDbPath20(), orgId, repoId, {
+    }) : await runLocalCurate(getDbPath21(), orgId, repoId, {
       dryRun,
       model: opts.model,
       preserveOriginals: opts.preserve !== false,
@@ -3452,7 +3679,7 @@ process.on("unhandledRejection", (err) => {
   runCleanup();
   process.exit(EXIT_ERROR);
 });
-var program = new Command28();
+var program = new Command29();
 program.name("unforgit").description("Unforgit \u2014 repository memory for agents and developers").version(pkg.version).option("--verbose", "Enable verbose output").option("--quiet", "Suppress non-essential output").option("--json", "Output results as JSON (for scripting)").hook("preAction", () => {
   const opts = program.opts();
   if (opts.quiet) setVerbosity(0);
@@ -3489,6 +3716,7 @@ program.addCommand(authCommand);
 program.addCommand(configCommand);
 program.addCommand(embeddingsCommand);
 program.addCommand(resetCommand);
+program.addCommand(backupsCommand);
 program.addCommand(doctorCommand);
 program.addCommand(curateCommand);
 program.addCommand(completionCommand);