@learnrudi/cli 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -14961,10 +14961,26 @@ COMMANDS
   stats            Show usage statistics
   search <query>   Search conversation history
   init             Initialize or migrate database
+  path             Show database file path
+  reset            Delete all data (requires --force)
+  vacuum           Compact database and reclaim space
+  backup [file]    Create database backup
+  prune [days]     Delete sessions older than N days (default: 90)
+  tables           Show table row counts
+
+OPTIONS
+  --force          Required for destructive operations
+  --dry-run        Preview without making changes
+  --json           Output as JSON
 
 EXAMPLES
   rudi db stats
   rudi db search "authentication bug"
+  rudi db reset --force
+  rudi db vacuum
+  rudi db backup ~/backups/rudi.db
+  rudi db prune 30 --dry-run
+  rudi db tables
 `,
     import: `
 rudi import - Import sessions from AI providers
@@ -17238,6 +17254,10 @@ function promptSecret(prompt) {
   });
 }
 
+// src/commands/db.js
+var import_fs10 = require("fs");
+var import_path10 = require("path");
+
 // ../packages/db/src/index.js
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 var import_path9 = __toESM(require("path"), 1);
@@ -18036,6 +18056,21 @@ async function cmdDb(args, flags) {
     case "path":
       console.log(getDbPath());
       break;
+    case "reset":
+      await dbReset(flags);
+      break;
+    case "vacuum":
+      dbVacuum(flags);
+      break;
+    case "backup":
+      dbBackup(args.slice(1), flags);
+      break;
+    case "prune":
+      dbPrune(args.slice(1), flags);
+      break;
+    case "tables":
+      dbTables(flags);
+      break;
     default:
       console.log(`
 rudi db - Database operations
@@ -18045,11 +18080,24 @@ COMMANDS
   search <query>     Search conversation history
   init               Initialize or migrate database
   path               Show database file path
+  reset              Delete all data (requires --force)
+  vacuum             Compact database and reclaim space
+  backup [file]      Create database backup
+  prune [days]       Delete sessions older than N days (default: 90)
+  tables             Show table row counts
+
+OPTIONS
+  --force            Required for destructive operations
+  --dry-run          Preview without making changes
 
 EXAMPLES
   rudi db stats
   rudi db search "authentication bug"
   rudi db init
+  rudi db reset --force
+  rudi db vacuum
+  rudi db backup ~/backups/rudi-backup.db
+  rudi db prune 30 --dry-run
 `);
   }
 }
@@ -18176,26 +18224,216 @@ function truncate(str, len) {
 function stripHighlight(str) {
   return str.replace(/>>>/g, "").replace(/<<</g, "");
 }
+async function dbReset(flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized.");
+    return;
+  }
+  if (!flags.force) {
+    console.error("This will delete ALL data from the database.");
+    console.error("Use --force to confirm.");
+    process.exit(1);
+  }
+  const db3 = getDb();
+  const dbPath = getDbPath();
+  const tables = ["sessions", "turns", "tool_calls", "projects"];
+  const counts = {};
+  for (const table of tables) {
+    try {
+      const row = db3.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+      counts[table] = row.count;
+    } catch (e) {
+      counts[table] = 0;
+    }
+  }
+  console.log("Deleting all data...");
+  console.log("\u2500".repeat(40));
+  const deleteOrder = ["tool_calls", "turns", "sessions", "projects"];
+  for (const table of deleteOrder) {
+    try {
+      db3.prepare(`DELETE FROM ${table}`).run();
+      console.log(`  ${table}: ${counts[table]} rows deleted`);
+    } catch (e) {
+    }
+  }
+  try {
+    db3.prepare("DELETE FROM turns_fts").run();
+    console.log("  turns_fts: cleared");
+  } catch (e) {
+  }
+  console.log("\u2500".repeat(40));
+  console.log("Database reset complete.");
+  console.log(`Path: ${dbPath}`);
+}
+function dbVacuum(flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized.");
+    return;
+  }
+  const dbPath = getDbPath();
+  const sizeBefore = getDbSize();
+  console.log("Compacting database...");
+  console.log(`  Before: ${formatBytes(sizeBefore)}`);
+  const db3 = getDb();
+  db3.exec("VACUUM");
+  const sizeAfter = getDbSize();
+  const saved = sizeBefore - sizeAfter;
+  console.log(`  After:  ${formatBytes(sizeAfter)}`);
+  if (saved > 0) {
+    console.log(`  Saved:  ${formatBytes(saved)} (${(saved / sizeBefore * 100).toFixed(1)}%)`);
+  } else {
+    console.log("  No space reclaimed.");
+  }
+}
+function dbBackup(args, flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized.");
+    return;
+  }
+  const dbPath = getDbPath();
+  let backupPath = args[0];
+  if (!backupPath) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    backupPath = (0, import_path10.join)((0, import_path10.dirname)(dbPath), `rudi-backup-${timestamp}.db`);
+  }
+  if (backupPath.startsWith("~")) {
+    backupPath = (0, import_path10.join)(process.env.HOME || "", backupPath.slice(1));
+  }
+  if ((0, import_fs10.existsSync)(backupPath) && !flags.force) {
+    console.error(`Backup file already exists: ${backupPath}`);
+    console.error("Use --force to overwrite.");
+    process.exit(1);
+  }
+  console.log("Creating backup...");
+  console.log(`  Source: ${dbPath}`);
+  console.log(`  Dest:   ${backupPath}`);
+  try {
+    const db3 = getDb();
+    db3.exec("VACUUM INTO ?", [backupPath]);
+  } catch (e) {
+    (0, import_fs10.copyFileSync)(dbPath, backupPath);
+  }
+  const size = getDbSize();
+  console.log(`  Size:   ${formatBytes(size)}`);
+  console.log("Backup complete.");
+}
+function dbPrune(args, flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized.");
+    return;
+  }
+  const days = parseInt(args[0]) || 90;
+  const dryRun = flags["dry-run"] || flags.dryRun;
+  const cutoffDate = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+  const db3 = getDb();
+  const toDelete = db3.prepare(`
+    SELECT COUNT(*) as count FROM sessions
+    WHERE last_active_at < ? OR (last_active_at IS NULL AND created_at < ?)
+  `).get(cutoffDate, cutoffDate);
+  const total = db3.prepare("SELECT COUNT(*) as count FROM sessions").get();
+  console.log(`Sessions older than ${days} days: ${toDelete.count}`);
+  console.log(`Total sessions: ${total.count}`);
+  console.log(`Cutoff date: ${cutoffDate.slice(0, 10)}`);
+  if (toDelete.count === 0) {
+    console.log("\nNo sessions to prune.");
+    return;
+  }
+  if (dryRun) {
+    console.log("\n(Dry run - no changes made)");
+    return;
+  }
+  if (!flags.force) {
+    console.error(`
+This will delete ${toDelete.count} sessions and their turns.`);
+    console.error("Use --force to confirm, or --dry-run to preview.");
+    process.exit(1);
+  }
+  console.log("\nDeleting old sessions...");
+  const sessionIds = db3.prepare(`
+    SELECT id FROM sessions
+    WHERE last_active_at < ? OR (last_active_at IS NULL AND created_at < ?)
+  `).all(cutoffDate, cutoffDate).map((r) => r.id);
+  let turnsDeleted = 0;
+  let toolCallsDeleted = 0;
+  for (const sessionId of sessionIds) {
+    const turnIds = db3.prepare("SELECT id FROM turns WHERE session_id = ?").all(sessionId).map((r) => r.id);
+    for (const turnId of turnIds) {
+      const result = db3.prepare("DELETE FROM tool_calls WHERE turn_id = ?").run(turnId);
+      toolCallsDeleted += result.changes;
+    }
+    const turnResult = db3.prepare("DELETE FROM turns WHERE session_id = ?").run(sessionId);
+    turnsDeleted += turnResult.changes;
+  }
+  const sessionResult = db3.prepare(`
+    DELETE FROM sessions
+    WHERE last_active_at < ? OR (last_active_at IS NULL AND created_at < ?)
+  `).run(cutoffDate, cutoffDate);
+  console.log(`  Sessions deleted: ${sessionResult.changes}`);
+  console.log(`  Turns deleted: ${turnsDeleted}`);
+  console.log(`  Tool calls deleted: ${toolCallsDeleted}`);
+  console.log('\nPrune complete. Run "rudi db vacuum" to reclaim disk space.');
+}
+function dbTables(flags) {
+  if (!isDatabaseInitialized()) {
+    console.log("Database not initialized.");
+    return;
+  }
+  const db3 = getDb();
+  const tables = db3.prepare(`
+    SELECT name FROM sqlite_master
+    WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+    ORDER BY name
+  `).all();
+  if (flags.json) {
+    const result = {};
+    for (const { name } of tables) {
+      try {
+        const row = db3.prepare(`SELECT COUNT(*) as count FROM "${name}"`).get();
+        result[name] = row.count;
+      } catch (e) {
+        result[name] = -1;
+      }
+    }
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log("\nDatabase Tables");
+  console.log("\u2550".repeat(40));
+  let totalRows = 0;
+  for (const { name } of tables) {
+    try {
+      const row = db3.prepare(`SELECT COUNT(*) as count FROM "${name}"`).get();
+      console.log(`  ${name.padEnd(25)} ${row.count.toLocaleString().padStart(10)}`);
+      totalRows += row.count;
+    } catch (e) {
+      console.log(`  ${name.padEnd(25)} ${"error".padStart(10)}`);
+    }
+  }
+  console.log("\u2500".repeat(40));
+  console.log(`  ${"Total".padEnd(25)} ${totalRows.toLocaleString().padStart(10)}`);
+  console.log(`
+  Size: ${formatBytes(getDbSize())}`);
+}
 
 // src/commands/import.js
-var import_fs10 = require("fs");
-var import_path10 = require("path");
+var import_fs11 = require("fs");
+var import_path11 = require("path");
 var import_os3 = require("os");
 var import_crypto2 = require("crypto");
 var PROVIDERS = {
   claude: {
     name: "Claude Code",
-    baseDir: (0, import_path10.join)((0, import_os3.homedir)(), ".claude", "projects"),
+    baseDir: (0, import_path11.join)((0, import_os3.homedir)(), ".claude", "projects"),
     pattern: /\.jsonl$/
   },
   codex: {
     name: "Codex",
-    baseDir: (0, import_path10.join)((0, import_os3.homedir)(), ".codex", "sessions"),
+    baseDir: (0, import_path11.join)((0, import_os3.homedir)(), ".codex", "sessions"),
     pattern: /\.jsonl$/
   },
   gemini: {
     name: "Gemini",
-    baseDir: (0, import_path10.join)((0, import_os3.homedir)(), ".gemini", "sessions"),
+    baseDir: (0, import_path11.join)((0, import_os3.homedir)(), ".gemini", "sessions"),
     pattern: /\.jsonl$/
   }
 };
@@ -18262,7 +18500,7 @@ async function importSessions(args, flags) {
     console.log(`
 \u25B6 ${provider.name}`);
     console.log(`  Source: ${provider.baseDir}`);
-    if (!(0, import_fs10.existsSync)(provider.baseDir)) {
+    if (!(0, import_fs11.existsSync)(provider.baseDir)) {
       console.log(`  \u26A0 Directory not found, skipping`);
       continue;
     }
@@ -18305,14 +18543,14 @@ async function importSessions(args, flags) {
     const now = Date.now();
     const maxAgeMs = maxAgeDays ? maxAgeDays * 24 * 60 * 60 * 1e3 : null;
     for (const filepath of files) {
-      const sessionId = (0, import_path10.basename)(filepath, ".jsonl");
+      const sessionId = (0, import_path11.basename)(filepath, ".jsonl");
       if (existingIds.has(sessionId)) {
         skipped.existing++;
         continue;
       }
       let stat;
       try {
-        stat = (0, import_fs10.statSync)(filepath);
+        stat = (0, import_fs11.statSync)(filepath);
       } catch (e) {
         skipped.error++;
         continue;
@@ -18410,7 +18648,7 @@ function showImportStatus(flags) {
   }
   console.log("\nProvider directories:");
   for (const [key, provider] of Object.entries(PROVIDERS)) {
-    const exists = (0, import_fs10.existsSync)(provider.baseDir);
+    const exists = (0, import_fs11.existsSync)(provider.baseDir);
     let count = 0;
     if (exists) {
       const files = findSessionFiles(provider.baseDir, provider.pattern);
@@ -18424,10 +18662,10 @@ function showImportStatus(flags) {
   console.log("To import: rudi import sessions [provider]");
 }
 function findSessionFiles(dir, pattern, files = []) {
-  if (!(0, import_fs10.existsSync)(dir)) return files;
+  if (!(0, import_fs11.existsSync)(dir)) return files;
   try {
-    for (const entry of (0, import_fs10.readdirSync)(dir, { withFileTypes: true })) {
-      const fullPath = (0, import_path10.join)(dir, entry.name);
+    for (const entry of (0, import_fs11.readdirSync)(dir, { withFileTypes: true })) {
+      const fullPath = (0, import_path11.join)(dir, entry.name);
       if (entry.isDirectory()) {
         findSessionFiles(fullPath, pattern, files);
       } else if (pattern.test(entry.name)) {
@@ -18440,11 +18678,11 @@ function findSessionFiles(dir, pattern, files = []) {
 }
 function parseSessionFile(filepath, provider) {
   try {
-    const stat = (0, import_fs10.statSync)(filepath);
-    const content = (0, import_fs10.readFileSync)(filepath, "utf-8");
+    const stat = (0, import_fs11.statSync)(filepath);
+    const content = (0, import_fs11.readFileSync)(filepath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     if (lines.length === 0) return null;
-    const sessionId = (0, import_path10.basename)(filepath, ".jsonl");
+    const sessionId = (0, import_path11.basename)(filepath, ".jsonl");
     const isAgent = sessionId.startsWith("agent-");
     let title = null;
     let cwd = null;
@@ -18476,7 +18714,7 @@ function parseSessionFile(filepath, provider) {
       title = isAgent ? "Agent Session" : "Imported Session";
     }
     if (!cwd) {
-      const parentDir = (0, import_path10.basename)((0, import_path10.dirname)(filepath));
+      const parentDir = (0, import_path11.basename)((0, import_path11.dirname)(filepath));
       if (parentDir.startsWith("-")) {
         cwd = parentDir.replace(/-/g, "/").replace(/^\//, "/");
       } else {
@@ -18500,7 +18738,7 @@ function parseSessionFile(filepath, provider) {
 }
 
 // src/commands/doctor.js
-var import_fs11 = __toESM(require("fs"), 1);
+var import_fs12 = __toESM(require("fs"), 1);
 async function cmdDoctor(args, flags) {
   console.log("RUDI Health Check");
   console.log("\u2550".repeat(50));
@@ -18518,12 +18756,12 @@ async function cmdDoctor(args, flags) {
     { path: PATHS.cache, name: "Cache" }
   ];
   for (const dir of dirs) {
-    const exists = import_fs11.default.existsSync(dir.path);
+    const exists = import_fs12.default.existsSync(dir.path);
     const status = exists ? "\u2713" : "\u2717";
     console.log(`  ${status} ${dir.name}: ${dir.path}`);
     if (!exists) {
       issues.push(`Missing directory: ${dir.name}`);
-      fixes.push(() => import_fs11.default.mkdirSync(dir.path, { recursive: true }));
+      fixes.push(() => import_fs12.default.mkdirSync(dir.path, { recursive: true }));
     }
   }
   console.log("\n\u{1F4BE} Database");
@@ -18593,8 +18831,8 @@ async function cmdDoctor(args, flags) {
 }
 
 // src/commands/update.js
-var import_fs12 = __toESM(require("fs"), 1);
-var import_path11 = __toESM(require("path"), 1);
+var import_fs13 = __toESM(require("fs"), 1);
+var import_path12 = __toESM(require("path"), 1);
 var import_child_process2 = require("child_process");
 init_src();
 init_src2();
@@ -18620,7 +18858,7 @@ async function cmdUpdate(args, flags) {
 async function updatePackage(pkgId, flags) {
   const [kind, name] = parsePackageId(pkgId);
   const installPath = getPackagePath(pkgId);
-  if (!import_fs12.default.existsSync(installPath)) {
+  if (!import_fs13.default.existsSync(installPath)) {
     return { success: false, error: "Package not installed" };
   }
   const pkg = await getPackage(pkgId);
@@ -18643,7 +18881,7 @@ async function updatePackage(pkgId, flags) {
   }
   if (pkg.pipPackage) {
     try {
-      const venvPip = import_path11.default.join(installPath, "venv", "bin", "pip");
+      const venvPip = import_path12.default.join(installPath, "venv", "bin", "pip");
       (0, import_child_process2.execSync)(`"${venvPip}" install --upgrade ${pkg.pipPackage}`, {
         stdio: flags.verbose ? "inherit" : "pipe"
       });
@@ -18660,7 +18898,7 @@ async function updatePackage(pkgId, flags) {
   if (kind === "runtime" && !pkg.npmPackage && !pkg.pipPackage) {
     try {
       const { downloadRuntime: downloadRuntime2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
-      import_fs12.default.rmSync(installPath, { recursive: true, force: true });
+      import_fs13.default.rmSync(installPath, { recursive: true, force: true });
       await downloadRuntime2(name, pkg.version || "latest", installPath, {
         onProgress: (p) => {
           if (flags.verbose) console.log(`  ${p.phase}...`);
@@ -18680,8 +18918,8 @@ async function updateAll(flags) {
   let failed = 0;
   for (const kind of kinds) {
     const dir = kind === "runtime" ? PATHS.runtimes : kind === "stack" ? PATHS.stacks : PATHS.prompts;
-    if (!import_fs12.default.existsSync(dir)) continue;
-    const entries = import_fs12.default.readdirSync(dir, { withFileTypes: true });
+    if (!import_fs13.default.existsSync(dir)) continue;
+    const entries = import_fs13.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const pkgId = `${kind}:${entry.name}`;
@@ -18700,14 +18938,14 @@ Updated ${updated} package(s)${failed > 0 ? `, ${failed} failed` : ""}`);
 }
 function getInstalledVersion(installPath, npmPackage) {
   try {
-    const pkgJsonPath = import_path11.default.join(installPath, "node_modules", npmPackage.replace("@", "").split("/")[0], "package.json");
-    if (import_fs12.default.existsSync(pkgJsonPath)) {
-      const pkgJson = JSON.parse(import_fs12.default.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJsonPath = import_path12.default.join(installPath, "node_modules", npmPackage.replace("@", "").split("/")[0], "package.json");
+    if (import_fs13.default.existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(import_fs13.default.readFileSync(pkgJsonPath, "utf-8"));
       return pkgJson.version;
     }
-    const rootPkgPath = import_path11.default.join(installPath, "package.json");
-    if (import_fs12.default.existsSync(rootPkgPath)) {
-      const rootPkg = JSON.parse(import_fs12.default.readFileSync(rootPkgPath, "utf-8"));
+    const rootPkgPath = import_path12.default.join(installPath, "package.json");
+    if (import_fs13.default.existsSync(rootPkgPath)) {
+      const rootPkg = JSON.parse(import_fs13.default.readFileSync(rootPkgPath, "utf-8"));
       const dep = rootPkg.dependencies?.[npmPackage];
       if (dep) return dep.replace(/[\^~]/, "");
     }
@@ -18716,30 +18954,30 @@ function getInstalledVersion(installPath, npmPackage) {
   return null;
 }
 function updateRuntimeMetadata(installPath, updates) {
-  const metaPath = import_path11.default.join(installPath, "runtime.json");
+  const metaPath = import_path12.default.join(installPath, "runtime.json");
   try {
     let meta = {};
-    if (import_fs12.default.existsSync(metaPath)) {
-      meta = JSON.parse(import_fs12.default.readFileSync(metaPath, "utf-8"));
+    if (import_fs13.default.existsSync(metaPath)) {
+      meta = JSON.parse(import_fs13.default.readFileSync(metaPath, "utf-8"));
     }
     meta = { ...meta, ...updates };
-    import_fs12.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+    import_fs13.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
   } catch {
   }
 }
 
 // db/index.js
 var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
-var import_path12 = __toESM(require("path"), 1);
+var import_path13 = __toESM(require("path"), 1);
 var import_os4 = __toESM(require("os"), 1);
-var import_fs13 = __toESM(require("fs"), 1);
-var PROMPT_STACK_HOME = import_path12.default.join(import_os4.default.homedir(), ".prompt-stack");
-var DB_PATH2 = import_path12.default.join(PROMPT_STACK_HOME, "prompt-stack.db");
+var import_fs14 = __toESM(require("fs"), 1);
+var PROMPT_STACK_HOME = import_path13.default.join(import_os4.default.homedir(), ".prompt-stack");
+var DB_PATH2 = import_path13.default.join(PROMPT_STACK_HOME, "prompt-stack.db");
 var db2 = null;
 function getDb2(options = {}) {
   if (!db2) {
-    if (!import_fs13.default.existsSync(PROMPT_STACK_HOME)) {
-      import_fs13.default.mkdirSync(PROMPT_STACK_HOME, { recursive: true });
+    if (!import_fs14.default.existsSync(PROMPT_STACK_HOME)) {
+      import_fs14.default.mkdirSync(PROMPT_STACK_HOME, { recursive: true });
     }
     db2 = new import_better_sqlite32.default(DB_PATH2, {
       readonly: options.readonly || false
@@ -18897,7 +19135,7 @@ function getBeforeCrashLogs() {
 }
 
 // src/commands/logs.js
-var import_fs14 = __toESM(require("fs"), 1);
+var import_fs15 = __toESM(require("fs"), 1);
 function parseTimeAgo(str) {
   const match = str.match(/^(\d+)([smhd])$/);
   if (!match) return null;
@@ -18997,7 +19235,7 @@ function exportLogs(logs, filepath, format) {
       });
       content = JSON.stringify(formatted, null, 2);
   }
-  import_fs14.default.writeFileSync(filepath, content, "utf-8");
+  import_fs15.default.writeFileSync(filepath, content, "utf-8");
   return filepath;
 }
 function printStats(stats) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@learnrudi/cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "RUDI CLI - Install and manage MCP stacks, runtimes, and AI agents",
   "type": "module",
   "main": "dist/index.cjs",