@learnrudi/cli 1.4.0 → 1.5.0

package/dist/index.cjs

@@ -781,17 +781,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path17) {
-      const ctrl = callVisitor(key, node, visitor, path17);
+    function visit_(key, node, visitor, path18) {
+      const ctrl = callVisitor(key, node, visitor, path18);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path17, ctrl);
-        return visit_(key, ctrl, visitor, path17);
+        replaceNode(key, path18, ctrl);
+        return visit_(key, ctrl, visitor, path18);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path17 = Object.freeze(path17.concat(node));
+          path18 = Object.freeze(path18.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path17);
+            const ci = visit_(i, node.items[i], visitor, path18);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -802,13 +802,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path17 = Object.freeze(path17.concat(node));
-          const ck = visit_("key", node.key, visitor, path17);
+          path18 = Object.freeze(path18.concat(node));
+          const ck = visit_("key", node.key, visitor, path18);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path17);
+          const cv = visit_("value", node.value, visitor, path18);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -829,17 +829,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path17) {
-      const ctrl = await callVisitor(key, node, visitor, path17);
+    async function visitAsync_(key, node, visitor, path18) {
+      const ctrl = await callVisitor(key, node, visitor, path18);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path17, ctrl);
-        return visitAsync_(key, ctrl, visitor, path17);
+        replaceNode(key, path18, ctrl);
+        return visitAsync_(key, ctrl, visitor, path18);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path17 = Object.freeze(path17.concat(node));
+          path18 = Object.freeze(path18.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path17);
+            const ci = await visitAsync_(i, node.items[i], visitor, path18);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -850,13 +850,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path17 = Object.freeze(path17.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path17);
+          path18 = Object.freeze(path18.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path18);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path17);
+          const cv = await visitAsync_("value", node.value, visitor, path18);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -883,23 +883,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path17) {
+    function callVisitor(key, node, visitor, path18) {
       if (typeof visitor === "function")
-        return visitor(key, node, path17);
+        return visitor(key, node, path18);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path17);
+        return visitor.Map?.(key, node, path18);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path17);
+        return visitor.Seq?.(key, node, path18);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path17);
+        return visitor.Pair?.(key, node, path18);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path17);
+        return visitor.Scalar?.(key, node, path18);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path17);
+        return visitor.Alias?.(key, node, path18);
       return void 0;
     }
-    function replaceNode(key, path17, node) {
-      const parent = path17[path17.length - 1];
+    function replaceNode(key, path18, node) {
+      const parent = path18[path18.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -1507,10 +1507,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path17, value) {
+    function collectionFromPath(schema, path18, value) {
       let v = value;
-      for (let i = path17.length - 1; i >= 0; --i) {
-        const k = path17[i];
+      for (let i = path18.length - 1; i >= 0; --i) {
+        const k = path18[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -1529,7 +1529,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path17) => path17 == null || typeof path17 === "object" && !!path17[Symbol.iterator]().next().done;
+    var isEmptyPath = (path18) => path18 == null || typeof path18 === "object" && !!path18[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -1559,11 +1559,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path17, value) {
-        if (isEmptyPath(path17))
+      addIn(path18, value) {
+        if (isEmptyPath(path18))
           this.add(value);
         else {
-          const [key, ...rest] = path17;
+          const [key, ...rest] = path18;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -1577,8 +1577,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path17) {
-        const [key, ...rest] = path17;
+      deleteIn(path18) {
+        const [key, ...rest] = path18;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -1592,8 +1592,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path17, keepScalar) {
-        const [key, ...rest] = path17;
+      getIn(path18, keepScalar) {
+        const [key, ...rest] = path18;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1611,8 +1611,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path17) {
-        const [key, ...rest] = path17;
+      hasIn(path18) {
+        const [key, ...rest] = path18;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -1622,8 +1622,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path17, value) {
-        const [key, ...rest] = path17;
+      setIn(path18, value) {
+        const [key, ...rest] = path18;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -4127,9 +4127,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path17, value) {
+      addIn(path18, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path17, value);
+          this.contents.addIn(path18, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -4204,14 +4204,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path17) {
-        if (Collection.isEmptyPath(path17)) {
+      deleteIn(path18) {
+        if (Collection.isEmptyPath(path18)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path17) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path18) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -4226,10 +4226,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path17, keepScalar) {
-        if (Collection.isEmptyPath(path17))
+      getIn(path18, keepScalar) {
+        if (Collection.isEmptyPath(path18))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path17, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path18, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -4240,10 +4240,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path17) {
-        if (Collection.isEmptyPath(path17))
+      hasIn(path18) {
+        if (Collection.isEmptyPath(path18))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path17) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path18) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -4260,13 +4260,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path17, value) {
-        if (Collection.isEmptyPath(path17)) {
+      setIn(path18, value) {
+        if (Collection.isEmptyPath(path18)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path17), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path18), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path17, value);
+          this.contents.setIn(path18, value);
         }
       }
       /**
@@ -6218,9 +6218,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path17) => {
+    visit.itemAtPath = (cst, path18) => {
       let item = cst;
-      for (const [field, index] of path17) {
+      for (const [field, index] of path18) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -6229,23 +6229,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path17) => {
-      const parent = visit.itemAtPath(cst, path17.slice(0, -1));
-      const field = path17[path17.length - 1][0];
+    visit.parentCollection = (cst, path18) => {
+      const parent = visit.itemAtPath(cst, path18.slice(0, -1));
+      const field = path18[path18.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path17, item, visitor) {
-      let ctrl = visitor(item, path17);
+    function _visit(path18, item, visitor) {
+      let ctrl = visitor(item, path18);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path17.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path18.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -6256,10 +6256,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path17);
+            ctrl = ctrl(item, path18);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path17) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path18) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -7544,14 +7544,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs19 = this.flowScalar(this.type);
+              const fs20 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs19, sep: [] });
+                map.items.push({ start, key: fs20, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs19);
+                this.stack.push(fs20);
               } else {
-                Object.assign(it, { key: fs19, sep: [] });
+                Object.assign(it, { key: fs20, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7679,13 +7679,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs19 = this.flowScalar(this.type);
+              const fs20 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs19, sep: [] });
+                fc.items.push({ start: [], key: fs20, sep: [] });
               else if (it.sep)
-                this.stack.push(fs19);
+                this.stack.push(fs20);
               else
-                Object.assign(it, { key: fs19, sep: [] });
+                Object.assign(it, { key: fs20, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -11186,8 +11186,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path17) {
-      let input = path17;
+    function removeDotSegments(path18) {
+      let input = path18;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -11386,8 +11386,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path17, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path17 && path17 !== "/" ? path17 : void 0;
+        const [path18, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path18 && path18 !== "/" ? path18 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -14740,12 +14740,12 @@ var require_dist2 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats2(ajv2, list, fs19, exportName) {
+    function addFormats2(ajv2, list, fs20, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv2.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv2.addFormat(f, fs19[f]);
+        ajv2.addFormat(f, fs20[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -14819,51 +14819,60 @@ rudi - RUDI CLI
 USAGE
   rudi <command> [options]
 
-COMMANDS
-  search <query>        Search for stacks, prompts, runtimes, binaries, agents
-  search --all          List all available packages in registry
-  install <pkg>         Install a package (stack, prompt, runtime, binary, agent)
-  remove <pkg>          Remove an installed package
-  update [pkg]          Update packages (or all if no pkg specified)
-  run <stack> [args]    Run a stack with optional arguments
-  list [kind]           List installed packages (stacks, prompts, runtimes, binaries, agents)
-
-  secrets set <name>    Set a secret
-  secrets list          List configured secrets (masked)
-  secrets remove <name> Remove a secret
-
+INTROSPECTION
+  home                  Show ~/.rudi structure and installed packages
+  stacks                List installed stacks
+  runtimes              List installed runtimes
+  binaries              List installed binaries
+  agents                List installed agents
+  prompts               List installed prompts
+  doctor                Check system health and dependencies
+  doctor --all          Show all available runtimes/binaries from registry
+
+PACKAGE MANAGEMENT
+  search <query>        Search registry for packages
+  search --all          List all available packages
+  install <pkg>         Install a package
+  remove <pkg>          Remove a package
+  update [pkg]          Update packages
+  run <stack>           Run a stack
+
+DATABASE
   db stats              Show database statistics
   db search <query>     Search conversation history
+  db reset --force      Delete all data
+  db vacuum             Compact and reclaim space
+  db tables             Show table row counts
 
-  import sessions       Import sessions from AI providers (claude, codex, gemini)
-  import status         Show import status for all providers
-
-  logs [options]        Query agent visibility logs
+SESSION IMPORT
+  import sessions       Import from AI providers (claude, codex, gemini)
+  import status         Show import status
 
-  doctor                Check system health and configuration
+SECRETS
+  secrets set <name>    Set a secret
+  secrets list          List configured secrets
+  secrets remove <name> Remove a secret
 
 OPTIONS
   -h, --help           Show help
   -v, --version        Show version
   --verbose            Verbose output
   --json               Output as JSON
-  --force              Force operation (skip confirmations)
+  --force              Force operation
 
 EXAMPLES
-  rudi search pdf              Search for PDF-related stacks
-  rudi install pdf-creator     Install the pdf-creator stack
-  rudi run pdf-creator         Run the pdf-creator stack
-  rudi list stacks             List installed stacks
-  rudi secrets set VERCEL_KEY  Set a secret
-
-PACKAGE NAMESPACES
-  stack:name           A stack (executable workflow)
-  prompt:name          A prompt template
-  runtime:name         A runtime interpreter (node, python, deno, bun)
-  binary:name          A utility binary (ffmpeg, imagemagick, ripgrep)
-  agent:name           An AI CLI tool (claude, codex, gemini, copilot)
-
-  If no namespace is given, 'stack:' is assumed.
+  rudi home                    Show ~/.rudi structure
+  rudi runtimes                List installed runtimes
+  rudi install runtime:python  Install Python in ~/.rudi
+  rudi install binary:ffmpeg   Install ffmpeg
+  rudi doctor --all            Show all available deps
+
+PACKAGE TYPES
+  stack:name           MCP server stack
+  runtime:name         Node, Python, Deno, Bun
+  binary:name          ffmpeg, ripgrep, etc.
+  agent:name           Claude, Codex, Gemini CLIs
+  prompt:name          Prompt template
 `);
 }
 function printCommandHelp(command) {
@@ -15007,6 +15016,27 @@ EXAMPLES
   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
+`,
+    home: `
+rudi home - Show ~/.rudi structure and status
+
+USAGE
+  rudi home [options]
+
+OPTIONS
+  --verbose        Show package details
+  --json           Output as JSON
+
+SHOWS
+  - Directory structure with sizes
+  - Installed package counts
+  - Database status
+  - Quick commands reference
+
+EXAMPLES
+  rudi home
+  rudi home --verbose
+  rudi home --json
 `,
     doctor: `
 rudi doctor - System health check
@@ -15016,13 +15046,20 @@ USAGE
 
 OPTIONS
   --fix            Attempt to fix issues
+  --all            Show all available runtimes/binaries from registry
 
 CHECKS
   - Directory structure
   - Database integrity
   - Installed packages
-  - Required runtimes
+  - Available runtimes (node, python, deno, bun)
+  - Available binaries (ffmpeg, ripgrep, etc.)
   - Secrets configuration
+
+EXAMPLES
+  rudi doctor
+  rudi doctor --fix
+  rudi doctor --all
 `,
     logs: `
 rudi logs - Query agent visibility logs
@@ -16611,11 +16648,11 @@ async function runStack(id, options = {}) {
   const startTime = Date.now();
   const packagePath = getPackagePath(id);
   const manifestPath = import_path7.default.join(packagePath, "manifest.json");
-  const { default: fs19 } = await import("fs");
-  if (!fs19.existsSync(manifestPath)) {
+  const { default: fs20 } = await import("fs");
+  if (!fs20.existsSync(manifestPath)) {
     throw new Error(`Stack manifest not found: ${id}`);
   }
-  const manifest = JSON.parse(fs19.readFileSync(manifestPath, "utf-8"));
+  const manifest = JSON.parse(fs20.readFileSync(manifestPath, "utf-8"));
   const { command, args } = resolveCommandFromManifest(manifest, packagePath);
   const secrets = await getSecrets(manifest.requires?.secrets || []);
   const runEnv = {
@@ -19085,9 +19122,143 @@ async function cmdDoctor(args, flags) {
   }
 }
 
-// src/commands/update.js
+// src/commands/home.js
 var import_fs14 = __toESM(require("fs"), 1);
 var import_path13 = __toESM(require("path"), 1);
+function formatBytes2(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+function getDirSize(dir) {
+  if (!import_fs14.default.existsSync(dir)) return 0;
+  let size = 0;
+  try {
+    const entries = import_fs14.default.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = import_path13.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        size += getDirSize(fullPath);
+      } else {
+        size += import_fs14.default.statSync(fullPath).size;
+      }
+    }
+  } catch {
+  }
+  return size;
+}
+function countItems(dir) {
+  if (!import_fs14.default.existsSync(dir)) return 0;
+  try {
+    return import_fs14.default.readdirSync(dir).filter((f) => !f.startsWith(".")).length;
+  } catch {
+    return 0;
+  }
+}
+async function cmdHome(args, flags) {
+  console.log("\u2550".repeat(60));
+  console.log("RUDI Home: " + PATHS.home);
+  console.log("\u2550".repeat(60));
+  if (flags.json) {
+    const data = {
+      home: PATHS.home,
+      directories: {},
+      packages: {},
+      database: {}
+    };
+    const dirs2 = [
+      { key: "stacks", path: PATHS.stacks },
+      { key: "prompts", path: PATHS.prompts },
+      { key: "runtimes", path: PATHS.runtimes },
+      { key: "binaries", path: PATHS.binaries },
+      { key: "agents", path: PATHS.agents },
+      { key: "cache", path: PATHS.cache }
+    ];
+    for (const dir of dirs2) {
+      data.directories[dir.key] = {
+        path: dir.path,
+        exists: import_fs14.default.existsSync(dir.path),
+        items: countItems(dir.path),
+        size: getDirSize(dir.path)
+      };
+    }
+    for (const kind of ["stack", "prompt", "runtime", "binary", "agent"]) {
+      data.packages[kind] = getInstalledPackages(kind).length;
+    }
+    data.database = {
+      initialized: isDatabaseInitialized(),
+      size: getDbSize() || 0
+    };
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  console.log("\n\u{1F4C1} Directory Structure\n");
+  const dirs = [
+    { name: "stacks", path: PATHS.stacks, icon: "\u{1F4E6}", desc: "MCP server stacks" },
+    { name: "prompts", path: PATHS.prompts, icon: "\u{1F4DD}", desc: "Prompt templates" },
+    { name: "runtimes", path: PATHS.runtimes, icon: "\u2699\uFE0F", desc: "Node, Python, Deno, Bun" },
+    { name: "binaries", path: PATHS.binaries, icon: "\u{1F527}", desc: "ffmpeg, ripgrep, etc." },
+    { name: "agents", path: PATHS.agents, icon: "\u{1F916}", desc: "Claude, Codex, Gemini CLIs" },
+    { name: "cache", path: PATHS.cache, icon: "\u{1F4BE}", desc: "Registry cache" }
+  ];
+  for (const dir of dirs) {
+    const exists = import_fs14.default.existsSync(dir.path);
+    const count = countItems(dir.path);
+    const size = getDirSize(dir.path);
+    console.log(`${dir.icon} ${dir.name}/`);
+    console.log(`   ${dir.desc}`);
+    if (exists) {
+      console.log(`   ${count} items, ${formatBytes2(size)}`);
+    } else {
+      console.log(`   (not created)`);
+    }
+    console.log();
+  }
+  console.log("\u{1F4BE} Database");
+  const dbPath = import_path13.default.join(PATHS.home, "rudi.db");
+  if (import_fs14.default.existsSync(dbPath)) {
+    const dbSize = getDbSize() || import_fs14.default.statSync(dbPath).size;
+    console.log(`   ${formatBytes2(dbSize)}`);
+    console.log(`   ${dbPath}`);
+  } else {
+    console.log(`   Not initialized`);
+  }
+  console.log();
+  console.log("\u2550".repeat(60));
+  console.log("Installed Packages");
+  console.log("\u2550".repeat(60));
+  const kinds = ["stack", "prompt", "runtime", "binary", "agent"];
+  let total = 0;
+  for (const kind of kinds) {
+    const packages = getInstalledPackages(kind);
+    const label = kind === "binary" ? "Binaries" : `${kind.charAt(0).toUpperCase() + kind.slice(1)}s`;
+    console.log(`  ${label.padEnd(12)} ${packages.length}`);
+    if (packages.length > 0 && flags.verbose) {
+      for (const pkg of packages.slice(0, 3)) {
+        console.log(`    - ${pkg.name || pkg.id}`);
+      }
+      if (packages.length > 3) {
+        console.log(`    ... and ${packages.length - 3} more`);
+      }
+    }
+    total += packages.length;
+  }
+  console.log("\u2500".repeat(30));
+  console.log(`  ${"Total".padEnd(12)} ${total}`);
+  console.log("\n\u{1F4CB} Quick Commands");
+  console.log("\u2500".repeat(30));
+  console.log("  rudi list stacks      Show installed stacks");
+  console.log("  rudi list runtimes    Show installed runtimes");
+  console.log("  rudi list binaries    Show installed binaries");
+  console.log("  rudi doctor --all     Check system dependencies");
+  console.log("  rudi db stats         Database statistics");
+}
+
+// src/commands/update.js
+var import_fs15 = __toESM(require("fs"), 1);
+var import_path14 = __toESM(require("path"), 1);
 var import_child_process3 = require("child_process");
 init_src();
 init_src2();
@@ -19113,7 +19284,7 @@ async function cmdUpdate(args, flags) {
 async function updatePackage(pkgId, flags) {
   const [kind, name] = parsePackageId(pkgId);
   const installPath = getPackagePath(pkgId);
-  if (!import_fs14.default.existsSync(installPath)) {
+  if (!import_fs15.default.existsSync(installPath)) {
     return { success: false, error: "Package not installed" };
   }
   const pkg = await getPackage(pkgId);
@@ -19136,7 +19307,7 @@ async function updatePackage(pkgId, flags) {
   }
   if (pkg.pipPackage) {
     try {
-      const venvPip = import_path13.default.join(installPath, "venv", "bin", "pip");
+      const venvPip = import_path14.default.join(installPath, "venv", "bin", "pip");
       (0, import_child_process3.execSync)(`"${venvPip}" install --upgrade ${pkg.pipPackage}`, {
         stdio: flags.verbose ? "inherit" : "pipe"
       });
@@ -19153,7 +19324,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_fs14.default.rmSync(installPath, { recursive: true, force: true });
+      import_fs15.default.rmSync(installPath, { recursive: true, force: true });
       await downloadRuntime2(name, pkg.version || "latest", installPath, {
         onProgress: (p) => {
           if (flags.verbose) console.log(`  ${p.phase}...`);
@@ -19173,8 +19344,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_fs14.default.existsSync(dir)) continue;
-    const entries = import_fs14.default.readdirSync(dir, { withFileTypes: true });
+    if (!import_fs15.default.existsSync(dir)) continue;
+    const entries = import_fs15.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const pkgId = `${kind}:${entry.name}`;
@@ -19193,14 +19364,14 @@ Updated ${updated} package(s)${failed > 0 ? `, ${failed} failed` : ""}`);
 }
 function getInstalledVersion(installPath, npmPackage) {
   try {
-    const pkgJsonPath = import_path13.default.join(installPath, "node_modules", npmPackage.replace("@", "").split("/")[0], "package.json");
-    if (import_fs14.default.existsSync(pkgJsonPath)) {
-      const pkgJson = JSON.parse(import_fs14.default.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJsonPath = import_path14.default.join(installPath, "node_modules", npmPackage.replace("@", "").split("/")[0], "package.json");
+    if (import_fs15.default.existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(import_fs15.default.readFileSync(pkgJsonPath, "utf-8"));
       return pkgJson.version;
     }
-    const rootPkgPath = import_path13.default.join(installPath, "package.json");
-    if (import_fs14.default.existsSync(rootPkgPath)) {
-      const rootPkg = JSON.parse(import_fs14.default.readFileSync(rootPkgPath, "utf-8"));
+    const rootPkgPath = import_path14.default.join(installPath, "package.json");
+    if (import_fs15.default.existsSync(rootPkgPath)) {
+      const rootPkg = JSON.parse(import_fs15.default.readFileSync(rootPkgPath, "utf-8"));
       const dep = rootPkg.dependencies?.[npmPackage];
       if (dep) return dep.replace(/[\^~]/, "");
     }
@@ -19209,30 +19380,30 @@ function getInstalledVersion(installPath, npmPackage) {
   return null;
 }
 function updateRuntimeMetadata(installPath, updates) {
-  const metaPath = import_path13.default.join(installPath, "runtime.json");
+  const metaPath = import_path14.default.join(installPath, "runtime.json");
   try {
     let meta = {};
-    if (import_fs14.default.existsSync(metaPath)) {
-      meta = JSON.parse(import_fs14.default.readFileSync(metaPath, "utf-8"));
+    if (import_fs15.default.existsSync(metaPath)) {
+      meta = JSON.parse(import_fs15.default.readFileSync(metaPath, "utf-8"));
     }
     meta = { ...meta, ...updates };
-    import_fs14.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+    import_fs15.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
   } catch {
   }
 }
 
 // db/index.js
 var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
-var import_path14 = __toESM(require("path"), 1);
+var import_path15 = __toESM(require("path"), 1);
 var import_os4 = __toESM(require("os"), 1);
-var import_fs15 = __toESM(require("fs"), 1);
-var RUDI_HOME2 = import_path14.default.join(import_os4.default.homedir(), ".rudi");
-var DB_PATH2 = import_path14.default.join(RUDI_HOME2, "rudi.db");
+var import_fs16 = __toESM(require("fs"), 1);
+var RUDI_HOME2 = import_path15.default.join(import_os4.default.homedir(), ".rudi");
+var DB_PATH2 = import_path15.default.join(RUDI_HOME2, "rudi.db");
 var db2 = null;
 function getDb2(options = {}) {
   if (!db2) {
-    if (!import_fs15.default.existsSync(RUDI_HOME2)) {
-      import_fs15.default.mkdirSync(RUDI_HOME2, { recursive: true });
+    if (!import_fs16.default.existsSync(RUDI_HOME2)) {
+      import_fs16.default.mkdirSync(RUDI_HOME2, { recursive: true });
     }
     db2 = new import_better_sqlite32.default(DB_PATH2, {
       readonly: options.readonly || false
@@ -19390,7 +19561,7 @@ function getBeforeCrashLogs() {
 }
 
 // src/commands/logs.js
-var import_fs16 = __toESM(require("fs"), 1);
+var import_fs17 = __toESM(require("fs"), 1);
 function parseTimeAgo(str) {
   const match = str.match(/^(\d+)([smhd])$/);
   if (!match) return null;
@@ -19490,7 +19661,7 @@ function exportLogs(logs, filepath, format) {
       });
       content = JSON.stringify(formatted, null, 2);
   }
-  import_fs16.default.writeFileSync(filepath, content, "utf-8");
+  import_fs17.default.writeFileSync(filepath, content, "utf-8");
   return filepath;
 }
 function printStats(stats) {
@@ -19616,8 +19787,8 @@ async function handleLogsCommand(args, flags) {
 }
 
 // src/commands/which.js
-var fs17 = __toESM(require("fs/promises"), 1);
-var path15 = __toESM(require("path"), 1);
+var fs18 = __toESM(require("fs/promises"), 1);
+var path16 = __toESM(require("path"), 1);
 var import_child_process4 = require("child_process");
 init_src();
 async function cmdWhich(args, flags) {
@@ -19686,7 +19857,7 @@ Installed stacks:`);
     if (runtimeInfo.entry) {
       console.log("");
       console.log("Run MCP server directly:");
-      const entryPath = path15.join(stackPath, runtimeInfo.entry);
+      const entryPath = path16.join(stackPath, runtimeInfo.entry);
       if (runtimeInfo.runtime === "node") {
         console.log(`  echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | node ${entryPath}`);
       } else if (runtimeInfo.runtime === "python") {
@@ -19705,27 +19876,27 @@ Installed stacks:`);
 async function detectRuntime(stackPath) {
   const runtimes = ["node", "python"];
   for (const runtime of runtimes) {
-    const runtimePath = path15.join(stackPath, runtime);
+    const runtimePath = path16.join(stackPath, runtime);
     try {
-      await fs17.access(runtimePath);
+      await fs18.access(runtimePath);
       if (runtime === "node") {
-        const distEntry = path15.join(runtimePath, "dist", "index.js");
-        const srcEntry = path15.join(runtimePath, "src", "index.ts");
+        const distEntry = path16.join(runtimePath, "dist", "index.js");
+        const srcEntry = path16.join(runtimePath, "src", "index.ts");
         try {
-          await fs17.access(distEntry);
+          await fs18.access(distEntry);
           return { runtime: "node", entry: `${runtime}/dist/index.js` };
         } catch {
           try {
-            await fs17.access(srcEntry);
+            await fs18.access(srcEntry);
             return { runtime: "node", entry: `${runtime}/src/index.ts` };
           } catch {
             return { runtime: "node", entry: null };
           }
         }
       } else if (runtime === "python") {
-        const entry = path15.join(runtimePath, "src", "index.py");
+        const entry = path16.join(runtimePath, "src", "index.py");
         try {
-          await fs17.access(entry);
+          await fs18.access(entry);
           return { runtime: "python", entry: `${runtime}/src/index.py` };
         } catch {
           return { runtime: "python", entry: null };
@@ -19741,21 +19912,21 @@ async function checkAuth(stackPath, runtime) {
   const authFiles = [];
   let configured = false;
   if (runtime === "node" || runtime === "python") {
-    const runtimePath = path15.join(stackPath, runtime);
-    const tokenPath = path15.join(runtimePath, "token.json");
+    const runtimePath = path16.join(stackPath, runtime);
+    const tokenPath = path16.join(runtimePath, "token.json");
     try {
-      await fs17.access(tokenPath);
+      await fs18.access(tokenPath);
       authFiles.push(`${runtime}/token.json`);
       configured = true;
     } catch {
-      const accountsPath = path15.join(runtimePath, "accounts");
+      const accountsPath = path16.join(runtimePath, "accounts");
       try {
-        const accounts = await fs17.readdir(accountsPath);
+        const accounts = await fs18.readdir(accountsPath);
         for (const account of accounts) {
           if (account.startsWith(".")) continue;
-          const accountTokenPath = path15.join(accountsPath, account, "token.json");
+          const accountTokenPath = path16.join(accountsPath, account, "token.json");
           try {
-            await fs17.access(accountTokenPath);
+            await fs18.access(accountTokenPath);
             authFiles.push(`${runtime}/accounts/${account}/token.json`);
             configured = true;
           } catch {
@@ -19765,9 +19936,9 @@ async function checkAuth(stackPath, runtime) {
       }
     }
   }
-  const envPath = path15.join(stackPath, ".env");
+  const envPath = path16.join(stackPath, ".env");
   try {
-    const envContent = await fs17.readFile(envPath, "utf-8");
+    const envContent = await fs18.readFile(envPath, "utf-8");
     const hasValues = envContent.split("\n").some((line) => {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) return false;
@@ -19811,8 +19982,8 @@ function checkIfRunning(stackName) {
 }
 
 // src/commands/auth.js
-var fs18 = __toESM(require("fs/promises"), 1);
-var path16 = __toESM(require("path"), 1);
+var fs19 = __toESM(require("fs/promises"), 1);
+var path17 = __toESM(require("path"), 1);
 var import_child_process5 = require("child_process");
 init_src();
 var net = __toESM(require("net"), 1);
@@ -19844,26 +20015,26 @@ function isPortAvailable(port) {
 async function detectRuntime2(stackPath) {
   const runtimes = ["node", "python"];
   for (const runtime of runtimes) {
-    const runtimePath = path16.join(stackPath, runtime);
+    const runtimePath = path17.join(stackPath, runtime);
     try {
-      await fs18.access(runtimePath);
+      await fs19.access(runtimePath);
       if (runtime === "node") {
-        const authTs = path16.join(runtimePath, "src", "auth.ts");
-        const authJs = path16.join(runtimePath, "dist", "auth.js");
+        const authTs = path17.join(runtimePath, "src", "auth.ts");
+        const authJs = path17.join(runtimePath, "dist", "auth.js");
         try {
-          await fs18.access(authTs);
+          await fs19.access(authTs);
           return { runtime: "node", authScript: authTs, useTsx: true };
         } catch {
           try {
-            await fs18.access(authJs);
+            await fs19.access(authJs);
             return { runtime: "node", authScript: authJs, useTsx: false };
           } catch {
           }
         }
       } else if (runtime === "python") {
-        const authPy = path16.join(runtimePath, "src", "auth.py");
+        const authPy = path17.join(runtimePath, "src", "auth.py");
         try {
-          await fs18.access(authPy);
+          await fs19.access(authPy);
           return { runtime: "python", authScript: authPy, useTsx: false };
         } catch {
         }
@@ -19913,14 +20084,14 @@ Installed stacks:`);
     console.log(`Using port: ${port}`);
     console.log("");
     let cmd;
-    const cwd = path16.dirname(authInfo.authScript);
+    const cwd = path17.dirname(authInfo.authScript);
     if (authInfo.runtime === "node") {
-      const distAuth = path16.join(cwd, "..", "dist", "auth.js");
+      const distAuth = path17.join(cwd, "..", "dist", "auth.js");
       let useBuiltInPort = false;
       let tempAuthScript = null;
       try {
-        await fs18.access(distAuth);
-        const distContent = await fs18.readFile(distAuth, "utf-8");
+        await fs19.access(distAuth);
+        const distContent = await fs19.readFile(distAuth, "utf-8");
         if (distContent.includes("findAvailablePort")) {
           console.log("Using compiled authentication script...");
           cmd = `node ${distAuth}${accountEmail ? ` ${accountEmail}` : ""}`;
@@ -19929,11 +20100,11 @@ Installed stacks:`);
       } catch {
       }
       if (!useBuiltInPort) {
-        const authContent = await fs18.readFile(authInfo.authScript, "utf-8");
+        const authContent = await fs19.readFile(authInfo.authScript, "utf-8");
         const tempExt = authInfo.useTsx ? ".ts" : ".mjs";
-        tempAuthScript = path16.join(cwd, "..", `auth-temp${tempExt}`);
+        tempAuthScript = path17.join(cwd, "..", `auth-temp${tempExt}`);
         const modifiedContent = authContent.replace(/localhost:3456/g, `localhost:${port}`).replace(/server\.listen\(3456/g, `server.listen(${port}`);
-        await fs18.writeFile(tempAuthScript, modifiedContent);
+        await fs19.writeFile(tempAuthScript, modifiedContent);
         if (authInfo.useTsx) {
           cmd = `npx tsx ${tempAuthScript}${accountEmail ? ` ${accountEmail}` : ""}`;
         } else {
@@ -19948,12 +20119,12 @@ Installed stacks:`);
           stdio: "inherit"
         });
         if (tempAuthScript) {
-          await fs18.unlink(tempAuthScript);
+          await fs19.unlink(tempAuthScript);
         }
       } catch (error) {
         if (tempAuthScript) {
           try {
-            await fs18.unlink(tempAuthScript);
+            await fs19.unlink(tempAuthScript);
           } catch {
           }
         }
@@ -20051,6 +20222,28 @@ async function main() {
       case "login":
         await cmdAuth(args, flags);
         break;
+      case "home":
+      case "status":
+        await cmdHome(args, flags);
+        break;
+      // Shortcuts for listing specific package types
+      case "stacks":
+        await cmdList(["stacks"], flags);
+        break;
+      case "prompts":
+        await cmdList(["prompts"], flags);
+        break;
+      case "runtimes":
+        await cmdList(["runtimes"], flags);
+        break;
+      case "binaries":
+      case "bins":
+      case "tools":
+        await cmdList(["binaries"], flags);
+        break;
+      case "agents":
+        await cmdList(["agents"], flags);
+        break;
       case "help":
         printHelp(args[0]);
         break;

package/package.json

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