@learnrudi/cli 1.0.0 → 1.2.0

package/dist/index.cjs

@@ -223,7 +223,7 @@ async function fetchIndex(options = {}) {
     const response = await fetch(url, {
       headers: {
         "Accept": "application/json",
-        "User-Agent": "pstack-cli/2.0"
+        "User-Agent": "rudi-cli/2.0"
       }
     });
     if (!response.ok) {
@@ -401,7 +401,7 @@ async function downloadRuntime(runtime, version, destPath, options = {}) {
   try {
     const response = await fetch(url, {
       headers: {
-        "User-Agent": "pstack-cli/2.0",
+        "User-Agent": "rudi-cli/2.0",
         "Accept": "application/octet-stream"
       }
     });
@@ -470,7 +470,7 @@ async function downloadTool(toolName, destPath, options = {}) {
       try {
         const response = await fetch(url, {
           headers: {
-            "User-Agent": "pstack-cli/2.0",
+            "User-Agent": "rudi-cli/2.0",
             "Accept": "application/octet-stream"
           }
         });
@@ -522,7 +522,7 @@ async function downloadTool(toolName, destPath, options = {}) {
     try {
       const response = await fetch(upstreamUrl, {
         headers: {
-          "User-Agent": "pstack-cli/2.0",
+          "User-Agent": "rudi-cli/2.0",
           "Accept": "application/octet-stream"
         }
       });
@@ -620,10 +620,10 @@ async function loadToolManifest(toolName) {
     }
   }
   try {
-    const url = `https://raw.githubusercontent.com/prompt/registry/main/catalog/binaries/${toolName}.json`;
+    const url = `https://raw.githubusercontent.com/learn-rudi/registry/main/catalog/binaries/${toolName}.json`;
     const response = await fetch(url, {
       headers: {
-        "User-Agent": "pstack-cli/2.0",
+        "User-Agent": "rudi-cli/2.0",
         "Accept": "application/json"
       }
     });
@@ -683,13 +683,13 @@ var init_src2 = __esm({
     import_path2 = __toESM(require("path"), 1);
     import_crypto = __toESM(require("crypto"), 1);
     init_src();
-    DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/prompt/registry/main/index.json";
-    RUNTIMES_DOWNLOAD_BASE = "https://github.com/prompt/registry/releases/download";
+    DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/learn-rudi/registry/main/index.json";
+    RUNTIMES_DOWNLOAD_BASE = "https://github.com/learn-rudi/registry/releases/download";
     CACHE_TTL = 24 * 60 * 60 * 1e3;
     LOCAL_REGISTRY_PATHS = process.env.USE_LOCAL_REGISTRY === "true" ? [
       import_path2.default.join(process.cwd(), "registry", "index.json"),
       import_path2.default.join(process.cwd(), "..", "registry", "index.json"),
-      "/Users/hoff/dev/prompt/registry/index.json"
+      "/Users/hoff/dev/RUDI/registry/index.json"
     ] : [];
     PACKAGE_KINDS2 = ["stack", "prompt", "runtime", "binary", "agent"];
     KIND_PLURALS = {
@@ -14830,6 +14830,9 @@ COMMANDS
   db stats              Show database statistics
   db search <query>     Search conversation history
 
+  import sessions       Import sessions from AI providers (claude, codex, gemini)
+  import status         Show import status for all providers
+
   logs [options]        Query agent visibility logs
 
   doctor                Check system health and configuration
@@ -14958,10 +14961,47 @@ 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
+
+USAGE
+  rudi import <command> [options]
+
+COMMANDS
+  sessions [provider]  Import sessions from provider (claude, codex, gemini, or all)
+  status               Show import status for all providers
+
+OPTIONS
+  --dry-run            Show what would be imported without making changes
+  --max-age=DAYS       Only import sessions newer than N days
+  --verbose            Show detailed progress
+
+EXAMPLES
+  rudi import sessions              Import from all providers
+  rudi import sessions claude       Import only Claude sessions
+  rudi import sessions --dry-run    Preview without importing
+  rudi import status                Check what's available to import
 `,
     doctor: `
 rudi doctor - System health check
@@ -17214,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);
@@ -17950,7 +17994,6 @@ function getToolsUsage(db3) {
 }
 
 // ../packages/db/src/index.js
-var PROMPT_STACK_HOME2 = PATHS.home;
 var DB_PATH = PATHS.dbFile;
 var db = null;
 function getDb(options = {}) {
@@ -18013,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
@@ -18022,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
 `);
   }
 }
@@ -18153,9 +18224,521 @@ 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_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_path11.join)((0, import_os3.homedir)(), ".claude", "projects"),
+    pattern: /\.jsonl$/
+  },
+  codex: {
+    name: "Codex",
+    baseDir: (0, import_path11.join)((0, import_os3.homedir)(), ".codex", "sessions"),
+    pattern: /\.jsonl$/
+  },
+  gemini: {
+    name: "Gemini",
+    baseDir: (0, import_path11.join)((0, import_os3.homedir)(), ".gemini", "sessions"),
+    pattern: /\.jsonl$/
+  }
+};
+async function cmdImport(args, flags) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "sessions":
+      await importSessions(args.slice(1), flags);
+      break;
+    case "status":
+      showImportStatus(flags);
+      break;
+    default:
+      console.log(`
+rudi import - Import data from AI agent providers
+
+COMMANDS
+  sessions [provider]  Import sessions from provider (claude, codex, gemini, or all)
+  status               Show import status for all providers
+
+OPTIONS
+  --dry-run            Show what would be imported without making changes
+  --max-age=DAYS       Only import sessions newer than N days
+  --verbose            Show detailed progress
+
+EXAMPLES
+  rudi import sessions              # Import from all providers
+  rudi import sessions claude       # Import only Claude sessions
+  rudi import sessions --dry-run    # Preview without importing
+  rudi import status                # Check what's available to import
+`);
+  }
+}
+async function importSessions(args, flags) {
+  const providerArg = args[0] || "all";
+  const dryRun = flags["dry-run"] || flags.dryRun;
+  const verbose = flags.verbose;
+  const maxAgeDays = flags["max-age"] ? parseInt(flags["max-age"]) : null;
+  if (!isDatabaseInitialized()) {
+    console.log("Initializing database...");
+    initSchema();
+  }
+  const db3 = getDb();
+  const providers = providerArg === "all" ? Object.keys(PROVIDERS) : [providerArg];
+  for (const p of providers) {
+    if (!PROVIDERS[p]) {
+      console.error(`Unknown provider: ${p}`);
+      console.error(`Available: ${Object.keys(PROVIDERS).join(", ")}`);
+      process.exit(1);
+    }
+  }
+  console.log("\u2550".repeat(60));
+  console.log("RUDI Session Import");
+  console.log("\u2550".repeat(60));
+  console.log(`Providers:  ${providers.join(", ")}`);
+  console.log(`Database:   ${getDbPath()}`);
+  console.log(`Max age:    ${maxAgeDays ? `${maxAgeDays} days` : "all"}`);
+  console.log(`Dry run:    ${dryRun ? "yes" : "no"}`);
+  console.log("\u2550".repeat(60));
+  let totalImported = 0;
+  let totalSkipped = 0;
+  for (const providerKey of providers) {
+    const provider = PROVIDERS[providerKey];
+    console.log(`
+\u25B6 ${provider.name}`);
+    console.log(`  Source: ${provider.baseDir}`);
+    if (!(0, import_fs11.existsSync)(provider.baseDir)) {
+      console.log(`  \u26A0 Directory not found, skipping`);
+      continue;
+    }
+    const existingIds = /* @__PURE__ */ new Set();
+    try {
+      const rows = db3.prepare(
+        "SELECT provider_session_id FROM sessions WHERE provider = ? AND provider_session_id IS NOT NULL"
+      ).all(providerKey);
+      for (const row of rows) {
+        existingIds.add(row.provider_session_id);
+      }
+    } catch (e) {
+    }
+    console.log(`  Existing: ${existingIds.size} sessions`);
+    const files = findSessionFiles(provider.baseDir, provider.pattern);
+    console.log(`  Found: ${files.length} session files`);
+    const insertStmt = db3.prepare(`
+      INSERT INTO sessions (
+        id, provider, provider_session_id, project_id,
+        origin, origin_imported_at, origin_native_file,
+        title, snippet, status, model,
+        inherit_project_prompt,
+        cwd, dir_scope, native_storage_path,
+        created_at, last_active_at,
+        turn_count, total_cost, total_input_tokens, total_output_tokens, total_duration_ms,
+        is_warmup, parent_session_id, agent_id, is_sidechain, session_type, version, user_type
+      ) VALUES (
+        ?, ?, ?, NULL,
+        'provider-import', ?, ?,
+        ?, '', 'active', ?,
+        1,
+        ?, 'project', ?,
+        ?, ?,
+        0, 0, 0, 0, 0,
+        0, ?, ?, ?, ?, '2.0.76', 'external'
+      )
+    `);
+    let imported = 0;
+    let skipped = { existing: 0, empty: 0, old: 0, error: 0 };
+    const now = Date.now();
+    const maxAgeMs = maxAgeDays ? maxAgeDays * 24 * 60 * 60 * 1e3 : null;
+    for (const filepath of files) {
+      const sessionId = (0, import_path11.basename)(filepath, ".jsonl");
+      if (existingIds.has(sessionId)) {
+        skipped.existing++;
+        continue;
+      }
+      let stat;
+      try {
+        stat = (0, import_fs11.statSync)(filepath);
+      } catch (e) {
+        skipped.error++;
+        continue;
+      }
+      if (stat.size === 0) {
+        skipped.empty++;
+        continue;
+      }
+      if (maxAgeMs && now - stat.mtimeMs > maxAgeMs) {
+        skipped.old++;
+        continue;
+      }
+      const session = parseSessionFile(filepath, providerKey);
+      if (!session) {
+        skipped.error++;
+        continue;
+      }
+      if (dryRun) {
+        if (verbose || imported < 5) {
+          console.log(`  [would import] ${sessionId}: ${session.title.slice(0, 40)}`);
+        }
+        imported++;
+        continue;
+      }
+      try {
+        const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+        insertStmt.run(
+          (0, import_crypto2.randomUUID)(),
+          providerKey,
+          sessionId,
+          nowIso,
+          filepath,
+          session.title,
+          session.model || "unknown",
+          session.cwd,
+          filepath,
+          session.createdAt,
+          session.lastActiveAt,
+          session.parentSessionId,
+          session.agentId,
+          session.isAgent ? 1 : 0,
+          session.sessionType
+        );
+        imported++;
+        if (verbose) {
+          console.log(`  \u2713 ${sessionId}: ${session.title.slice(0, 40)}`);
+        } else if (imported % 100 === 0) {
+          console.log(`  Imported ${imported}...`);
+        }
+      } catch (e) {
+        skipped.error++;
+        if (verbose) {
+          console.log(`  \u2717 ${sessionId}: ${e.message}`);
+        }
+      }
+    }
+    console.log(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    console.log(`  Imported: ${imported}`);
+    console.log(`  Skipped:  ${skipped.existing} existing, ${skipped.empty} empty, ${skipped.old} old, ${skipped.error} errors`);
+    totalImported += imported;
+    totalSkipped += skipped.existing + skipped.empty + skipped.old + skipped.error;
+  }
+  console.log("\n" + "\u2550".repeat(60));
+  console.log(`Total imported: ${totalImported}`);
+  console.log(`Total skipped:  ${totalSkipped}`);
+  console.log("\u2550".repeat(60));
+  if (dryRun) {
+    console.log("\n(Dry run - no changes made)");
+  }
+  if (!dryRun && totalImported > 0) {
+    const count = db3.prepare("SELECT COUNT(*) as count FROM sessions").get();
+    console.log(`
+Total sessions in database: ${count.count}`);
+  }
+}
+function showImportStatus(flags) {
+  console.log("\u2550".repeat(60));
+  console.log("Import Status");
+  console.log("\u2550".repeat(60));
+  if (!isDatabaseInitialized()) {
+    console.log("\nDatabase: Not initialized");
+    console.log("Run: rudi db init");
+  } else {
+    const db3 = getDb();
+    const stats = db3.prepare(`
+      SELECT provider, COUNT(*) as count
+      FROM sessions
+      WHERE status = 'active'
+      GROUP BY provider
+    `).all();
+    console.log("\nDatabase sessions:");
+    for (const row of stats) {
+      console.log(`  ${row.provider}: ${row.count}`);
+    }
+  }
+  console.log("\nProvider directories:");
+  for (const [key, provider] of Object.entries(PROVIDERS)) {
+    const exists = (0, import_fs11.existsSync)(provider.baseDir);
+    let count = 0;
+    if (exists) {
+      const files = findSessionFiles(provider.baseDir, provider.pattern);
+      count = files.length;
+    }
+    console.log(`  ${provider.name}:`);
+    console.log(`    Path: ${provider.baseDir}`);
+    console.log(`    Status: ${exists ? `${count} session files` : "not found"}`);
+  }
+  console.log("\n" + "\u2550".repeat(60));
+  console.log("To import: rudi import sessions [provider]");
+}
+function findSessionFiles(dir, pattern, files = []) {
+  if (!(0, import_fs11.existsSync)(dir)) return files;
+  try {
+    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)) {
+        files.push(fullPath);
+      }
+    }
+  } catch (e) {
+  }
+  return files;
+}
+function parseSessionFile(filepath, provider) {
+  try {
+    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_path11.basename)(filepath, ".jsonl");
+    const isAgent = sessionId.startsWith("agent-");
+    let title = null;
+    let cwd = null;
+    let createdAt = null;
+    let model = null;
+    let parentSessionId = null;
+    let agentId = isAgent ? sessionId.replace("agent-", "") : null;
+    for (const line of lines.slice(0, 50)) {
+      try {
+        const data = JSON.parse(line);
+        if (!cwd && data.cwd) cwd = data.cwd;
+        if (!createdAt && data.timestamp) createdAt = data.timestamp;
+        if (!model && data.model) model = data.model;
+        if (!parentSessionId && (data.parentSessionId || data.parentUuid)) {
+          parentSessionId = data.parentSessionId || data.parentUuid;
+        }
+        if (!agentId && data.agentId) agentId = data.agentId;
+        if (!title) {
+          const msg = data.message?.content || data.userMessage || (data.type === "user" ? data.message?.content : null);
+          if (msg && msg.length > 2) {
+            title = msg.split("\n")[0].slice(0, 50).trim();
+          }
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+    if (!title || title.length < 3) {
+      title = isAgent ? "Agent Session" : "Imported Session";
+    }
+    if (!cwd) {
+      const parentDir = (0, import_path11.basename)((0, import_path11.dirname)(filepath));
+      if (parentDir.startsWith("-")) {
+        cwd = parentDir.replace(/-/g, "/").replace(/^\//, "/");
+      } else {
+        cwd = (0, import_os3.homedir)();
+      }
+    }
+    return {
+      title,
+      cwd,
+      createdAt: createdAt || stat.birthtime.toISOString(),
+      lastActiveAt: stat.mtime.toISOString(),
+      model,
+      isAgent,
+      agentId,
+      parentSessionId,
+      sessionType: isAgent ? "agent" : "main"
+    };
+  } catch (e) {
+    return null;
+  }
+}
 
 // src/commands/doctor.js
-var import_fs10 = __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));
@@ -18173,12 +18756,12 @@ async function cmdDoctor(args, flags) {
     { path: PATHS.cache, name: "Cache" }
   ];
   for (const dir of dirs) {
-    const exists = import_fs10.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_fs10.default.mkdirSync(dir.path, { recursive: true }));
+      fixes.push(() => import_fs12.default.mkdirSync(dir.path, { recursive: true }));
     }
   }
   console.log("\n\u{1F4BE} Database");
@@ -18248,8 +18831,8 @@ async function cmdDoctor(args, flags) {
 }
 
 // src/commands/update.js
-var import_fs11 = __toESM(require("fs"), 1);
-var import_path10 = __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();
@@ -18275,7 +18858,7 @@ async function cmdUpdate(args, flags) {
 async function updatePackage(pkgId, flags) {
   const [kind, name] = parsePackageId(pkgId);
   const installPath = getPackagePath(pkgId);
-  if (!import_fs11.default.existsSync(installPath)) {
+  if (!import_fs13.default.existsSync(installPath)) {
     return { success: false, error: "Package not installed" };
   }
   const pkg = await getPackage(pkgId);
@@ -18298,7 +18881,7 @@ async function updatePackage(pkgId, flags) {
   }
   if (pkg.pipPackage) {
     try {
-      const venvPip = import_path10.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"
       });
@@ -18315,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_fs11.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}...`);
@@ -18335,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_fs11.default.existsSync(dir)) continue;
-    const entries = import_fs11.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}`;
@@ -18355,14 +18938,14 @@ Updated ${updated} package(s)${failed > 0 ? `, ${failed} failed` : ""}`);
 }
 function getInstalledVersion(installPath, npmPackage) {
   try {
-    const pkgJsonPath = import_path10.default.join(installPath, "node_modules", npmPackage.replace("@", "").split("/")[0], "package.json");
-    if (import_fs11.default.existsSync(pkgJsonPath)) {
-      const pkgJson = JSON.parse(import_fs11.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_path10.default.join(installPath, "package.json");
-    if (import_fs11.default.existsSync(rootPkgPath)) {
-      const rootPkg = JSON.parse(import_fs11.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(/[\^~]/, "");
     }
@@ -18371,30 +18954,30 @@ function getInstalledVersion(installPath, npmPackage) {
   return null;
 }
 function updateRuntimeMetadata(installPath, updates) {
-  const metaPath = import_path10.default.join(installPath, "runtime.json");
+  const metaPath = import_path12.default.join(installPath, "runtime.json");
   try {
     let meta = {};
-    if (import_fs11.default.existsSync(metaPath)) {
-      meta = JSON.parse(import_fs11.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_fs11.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_path11 = __toESM(require("path"), 1);
-var import_os3 = __toESM(require("os"), 1);
-var import_fs12 = __toESM(require("fs"), 1);
-var PROMPT_STACK_HOME3 = import_path11.default.join(import_os3.default.homedir(), ".prompt-stack");
-var DB_PATH2 = import_path11.default.join(PROMPT_STACK_HOME3, "prompt-stack.db");
+var import_path13 = __toESM(require("path"), 1);
+var import_os4 = __toESM(require("os"), 1);
+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_fs12.default.existsSync(PROMPT_STACK_HOME3)) {
-      import_fs12.default.mkdirSync(PROMPT_STACK_HOME3, { 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
@@ -18552,7 +19135,7 @@ function getBeforeCrashLogs() {
 }
 
 // src/commands/logs.js
-var import_fs13 = __toESM(require("fs"), 1);
+var import_fs15 = __toESM(require("fs"), 1);
 function parseTimeAgo(str) {
   const match = str.match(/^(\d+)([smhd])$/);
   if (!match) return null;
@@ -18652,7 +19235,7 @@ function exportLogs(logs, filepath, format) {
       });
       content = JSON.stringify(formatted, null, 2);
   }
-  import_fs13.default.writeFileSync(filepath, content, "utf-8");
+  import_fs15.default.writeFileSync(filepath, content, "utf-8");
   return filepath;
 }
 function printStats(stats) {
@@ -19189,6 +19772,9 @@ async function main() {
       case "database":
         await cmdDb(args, flags);
         break;
+      case "import":
+        await cmdImport(args, flags);
+        break;
       case "doctor":
       case "check":
         await cmdDoctor(args, flags);

package/package.json

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