@donotdev/cli 0.0.18 → 0.0.20

package/dist/bin/donotdev.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // packages/tooling/src/bundler/utils.ts
 import { Buffer as Buffer2 } from "node:buffer";
@@ -30,241 +35,905 @@ var init_utils = __esm({
   }
 });
 
-// packages/cli/src/bin/dndev.mjs
-init_utils();
-import { readFileSync } from "node:fs";
-import { Command } from "commander";
-var CLI_VERSION = JSON.parse(
-  readFileSync(new URL("../../package.json", import.meta.url), "utf-8")
-).version;
-var args = process.argv.slice(2);
-if (args.length === 1 && (args[0] === "--version" || args[0] === "-v")) {
-  console.log(CLI_VERSION);
-  process.exit(0);
+// packages/tooling/src/cli/command-registry.ts
+var command_registry_exports = {};
+__export(command_registry_exports, {
+  COMMAND_REGISTRY: () => COMMAND_REGISTRY,
+  generateHelpText: () => generateHelpText,
+  getAppCommandNames: () => getAppCommandNames,
+  getBundleCommandNames: () => getBundleCommandNames,
+  getPublicCommands: () => getPublicCommands
+});
+function baseName(commanderName) {
+  return commanderName.split(" ")[0] ?? commanderName;
 }
-if (args.length === 0 || args.length === 1 && (args[0] === "--help" || args[0] === "-h")) {
-  console.log(`DoNotDev CLI v${CLI_VERSION}
+function getPublicCommands() {
+  return COMMAND_REGISTRY.filter((cmd) => cmd.public === true);
+}
+function getAppCommandNames() {
+  const names = [];
+  for (const cmd of COMMAND_REGISTRY) {
+    if (!cmd.appCommand) continue;
+    names.push(baseName(cmd.name));
+    if (cmd.alias) {
+      const aliases = Array.isArray(cmd.alias) ? cmd.alias : [cmd.alias];
+      names.push(...aliases);
+    }
+  }
+  return names;
+}
+function getBundleCommandNames() {
+  return COMMAND_REGISTRY.filter((cmd) => cmd.public === true).map(
+    (cmd) => cmd.wrapperFile ?? baseName(cmd.name)
+  );
+}
+function generateHelpText(cli) {
+  const commands = cli === "dndev" ? COMMAND_REGISTRY.filter((cmd) => cmd.public === true) : COMMAND_REGISTRY;
+  const cliName = cli === "dn" ? "dn" : "dndev";
+  const title = cli === "dn" ? "DoNotDev Framework CLI - Internal Tooling" : "DoNotDev CLI";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const cmd of commands) {
+    const list = grouped.get(cmd.category) ?? [];
+    list.push(cmd);
+    grouped.set(cmd.category, list);
+  }
+  const CATEGORY_LABELS = {
+    project: "Project Commands",
+    development: "Development Commands",
+    build: "Build & Maintenance",
+    deployment: "Deployment",
+    content: "Content",
+    internal: "Internal",
+    other: "Other"
+  };
+  const sections = [];
+  for (const [cat, cmds] of grouped) {
+    const label = CATEGORY_LABELS[cat] ?? cat;
+    const lines = cmds.map((cmd) => {
+      const nameStr = cmd.name;
+      const aliasStr = cmd.alias ? `, ${Array.isArray(cmd.alias) ? cmd.alias.join(", ") : cmd.alias}` : "";
+      const left = `  ${nameStr}${aliasStr}`;
+      const pad = Math.max(2, 28 - left.length);
+      return `${left}${" ".repeat(pad)}${cmd.description}`;
+    });
+    sections.push(`${label}:
+${lines.join("\n")}`);
+  }
+  const header = cli === "dn" ? `${title}
 
-Usage: dndev <command>[:<app>] [options]
+Usage: ${cliName} <command>[:<app>] [options]` : `${title}
 
-Commands:
-  init, create-project    Create a new DoNotDev project
-  create-app [name]       Add app (--builder, --host, --functions, --backend)
-  dev [app]               Start development server
-  build [app]             Build for production
-  preview [app]           Preview production build
-  emu [app]               Start dev with local backend
-  format                  Format code with Prettier
-  tc [app]                Type-check TypeScript (all packages or specific app)
-  deploy [app]            Deploy to Firebase
-  staging [subcommand]    Deploy to staging/UAT (deploy, deploy:hosting, deploy:functions, seed, status)
-  sync-secrets            Sync env vars to Firebase/Vercel/GitHub Secrets
-  make-admin [userId]     Set a user as admin (custom claims / app_metadata)
-  setup [provider]        Set up provider credentials (firebase, supabase, vercel, stripe, oauth, auth)
-  doctor                  Check project health: validate provider connections and .env files
-  cacheout [app]          Clear build caches
-  bump                    Update framework packages and peer dependencies
-  agent                   Configure MCP server for AI agents (Cursor, Claude, Gemini)
-  wai                     Output WAI-WAY activation prompt (paste into any AI agent)
+Usage: ${cliName} <command>[:<app>] [options]`;
+  const footer = cli === "dn" ? `Options:
+  -v, --version           Display version number
+  -h, --help              Display this help
+
+Examples:
+  ${cliName} dev                  Start dev server
+  ${cliName} dev:demo             Start dev server for 'demo' app
+  ${cliName} create-app           Interactive app creation
+  ${cliName} create-app my-app    Create 'my-app' with defaults (vite, frontend-only)
+  ${cliName} create-app my-app --builder next --host vercel  Next.js + Vercel hosting
+  ${cliName} create-app my-app --functions firebase --backend firebase  Full Firebase stack
+  ${cliName} bundle               Build all packages
+  ${cliName} lint --fix           Lint and auto-fix issues
+  ${cliName} wai                  Output WAI-WAY activation prompt
 
-Options:
+Run '${cliName} <command> --help' for command-specific help.` : `Options:
   -v, --version           Display version number
   -h, --help              Display this help
 
 Examples:
-  dndev init my-project   Create a new project
-  dndev create-app        Interactive app creation
-  dndev create-app my-app Create 'my-app' with defaults (vite, frontend-only)
-  dndev create-app my-app --builder next --host vercel  Next.js + Vercel hosting
-  dndev create-app my-app --functions firebase --backend firebase  Full Firebase stack
-  dndev create-app my-app --backend supabase --project my-fb-id  Supabase + custom project
-  dndev dev               Start dev server
-  dndev dev:web           Start dev server for 'web' app
-  dndev agent             Configure MCP for all AI agents
-  dndev wai               Output WAI-WAY activation prompt
+  ${cliName} init my-project   Create a new project
+  ${cliName} create-app        Interactive app creation
+  ${cliName} create-app my-app Create 'my-app' with defaults (vite, frontend-only)
+  ${cliName} create-app my-app --builder next --host vercel  Next.js + Vercel hosting
+  ${cliName} create-app my-app --functions firebase --backend firebase  Full Firebase stack
+  ${cliName} create-app my-app --backend supabase --project my-fb-id  Supabase + custom project
+  ${cliName} dev               Start dev server
+  ${cliName} dev:web           Start dev server for 'web' app
+  ${cliName} agent             Configure MCP for all AI agents
+  ${cliName} wai               Output WAI-WAY activation prompt
 
-Run 'dndev <command> --help' for command-specific help.`);
-  process.exit(0);
+Run '${cliName} <command> --help' for command-specific help.`;
+  return `${header}
+
+${sections.join("\n\n")}
+
+${footer}
+`;
+}
+var COMMAND_REGISTRY;
+var init_command_registry = __esm({
+  "packages/tooling/src/cli/command-registry.ts"() {
+    init_utils();
+    COMMAND_REGISTRY = [
+      // ---------------------------------------------------------------------------
+      // Project
+      // ---------------------------------------------------------------------------
+      {
+        name: "init [name]",
+        description: "Create a new DoNotDev project",
+        alias: "create-project",
+        category: "project",
+        public: true,
+        loader: "../scaffolding/create-project.ts",
+        wrapperFile: "create-project",
+        exportName: "createProject"
+      },
+      {
+        name: "create-app [name]",
+        description: "Add a new app to existing project",
+        category: "project",
+        public: true,
+        options: [
+          { flags: "--name <name>", description: "App name (non-interactive)" },
+          {
+            flags: "--builder <builder>",
+            description: "Framework: vite, next, or expo (default: vite)"
+          },
+          {
+            flags: "--host <host>",
+            description: "Hosting: none, vercel, or firebase (default: none)"
+          },
+          {
+            flags: "--functions <runtime>",
+            description: "Functions: none, vercel, firebase, or supabase (default: none)"
+          },
+          {
+            flags: "--backend <backend>",
+            description: "BaaS: none, firebase, or supabase (default: none)"
+          }
+        ],
+        loader: "../scaffolding/create-app.ts",
+        wrapperFile: "create-app",
+        exportName: "createApp"
+      },
+      {
+        name: "get-demo",
+        description: "Copy the demo app into apps/demo",
+        category: "project",
+        public: true,
+        options: [
+          {
+            flags: "--force",
+            description: "Replace existing demo app without prompting"
+          }
+        ],
+        loader: "../scaffolding/get-demo.ts",
+        wrapperFile: "get-demo",
+        exportName: "getDemo"
+      },
+      // ---------------------------------------------------------------------------
+      // Development
+      // ---------------------------------------------------------------------------
+      {
+        name: "dev [app]",
+        description: "Start development server",
+        category: "development",
+        public: true,
+        appCommand: true,
+        actionPattern: "app",
+        options: [
+          { flags: "-c, --concurrency <n>", description: "set concurrency" }
+        ],
+        loader: "../apps/dev.ts",
+        exportName: "dev"
+      },
+      {
+        name: "build [app]",
+        description: "Build for production",
+        category: "development",
+        public: true,
+        appCommand: true,
+        actionPattern: "app",
+        loader: "../apps/build.ts",
+        exportName: "build"
+      },
+      {
+        name: "preview [app]",
+        description: "Preview production build",
+        category: "development",
+        public: true,
+        appCommand: true,
+        actionPattern: "app",
+        loader: "../apps/preview.ts",
+        exportName: "preview"
+      },
+      {
+        name: "emu [app]",
+        description: "Start dev with local backend",
+        category: "development",
+        public: true,
+        appCommand: true,
+        actionPattern: "app",
+        options: [
+          {
+            flags: "--services <services>",
+            description: "Comma-separated list of services: auth,functions,firestore,stripe"
+          },
+          { flags: "--auth", description: "Enable Auth emulator" },
+          { flags: "--firestore", description: "Enable Firestore emulator" },
+          { flags: "--stripe", description: "Enable Stripe webhook forwarding" }
+        ],
+        loader: "../apps/emu.ts",
+        exportName: "emu"
+      },
+      {
+        name: "format",
+        description: "Format code with framework standards",
+        category: "development",
+        public: true,
+        loader: "../quality/format.ts",
+        exportName: "format"
+      },
+      {
+        name: "lint",
+        description: "Lint code using ESLint",
+        category: "development",
+        options: [
+          { flags: "-f, --fix", description: "automatically fix linting issues" }
+        ],
+        loader: "../quality/lint.ts",
+        exportName: "lint"
+      },
+      {
+        name: "type-check [package]",
+        description: "Type-check packages",
+        alias: "tc",
+        category: "development",
+        public: true,
+        appCommand: true,
+        options: [
+          {
+            flags: "--package <package>",
+            description: "type-check a specific package"
+          }
+        ],
+        loader: "../quality/type-check.ts",
+        wrapperFile: "type-check",
+        exportName: "typeCheck"
+      },
+      {
+        name: "check-ui",
+        description: "Check UI compliance with STYLING_SYSTEM.md rules",
+        category: "development",
+        options: [
+          { flags: "-d, --dir <dir>", description: "target directory to check" },
+          { flags: "-r, --report <file>", description: "save report to JSON file" }
+        ],
+        loader: "../quality/check-ui.ts",
+        exportName: "checkUI"
+      },
+      {
+        name: "check-expo",
+        description: "Check Expo API parity with web packages (exports, props, hooks)",
+        category: "development",
+        loader: "../quality/check-expo-api.ts",
+        exportName: "checkExpo"
+      },
+      {
+        name: "check-translations [target]",
+        description: "Validate translation files across languages (missing keys, type mismatches)",
+        category: "development",
+        options: [
+          {
+            flags: "-r, --report <file>",
+            description: "Write full report to file"
+          },
+          { flags: "--all", description: "Check all apps and i18n package" }
+        ],
+        loader: "../quality/check-translations.ts",
+        exportName: "checkTranslations"
+      },
+      {
+        name: "sync-translations [app]",
+        description: "Sync locale structure from English reference, fix missing keys and array lengths",
+        category: "development",
+        loader: "../quality/sync-translations.ts"
+      },
+      {
+        name: "validate-package [package]",
+        description: "Validate package(s) before bundle/publish (checklist: types, CSS, exports, etc.)",
+        category: "development",
+        options: [{ flags: "--all", description: "validate all packages" }],
+        loader: "../quality/validate-package.ts",
+        exportName: "validatePackage"
+      },
+      // ---------------------------------------------------------------------------
+      // Build & Maintenance
+      // ---------------------------------------------------------------------------
+      {
+        name: "bundle [package]",
+        description: "Build all packages, create changeset, and publish",
+        category: "build",
+        options: [
+          { flags: "--package <package>", description: "build a specific package" },
+          { flags: "--all", description: "build all packages" },
+          { flags: "--skip-build", description: "skip build step" },
+          { flags: "--skip-minify", description: "skip minification" },
+          {
+            flags: "--changeset",
+            description: "create changeset before publish (default: skip)"
+          },
+          { flags: "--skip-publish", description: "skip publishing" },
+          {
+            flags: "--skip-validation",
+            description: "skip package validation before build"
+          },
+          {
+            flags: "--verdaccio",
+            description: "publish to local Verdaccio registry instead of npm"
+          },
+          {
+            flags: "--tar",
+            description: "Create tarballs + update test repo (no publish)"
+          },
+          { flags: "--force", description: "force publish (npm publish --force)" }
+        ],
+        loader: "../bundler/bundle.ts",
+        exportName: "bundle"
+      },
+      {
+        name: "clean",
+        description: "Clean build artifacts, caches, and node_modules",
+        category: "build",
+        loader: "../maintenance/clean.ts",
+        exportName: "clean"
+      },
+      {
+        name: "cacheout [app]",
+        description: "Clear build caches without touching node_modules",
+        alias: "co",
+        category: "build",
+        public: true,
+        appCommand: true,
+        options: [
+          { flags: "--app <app>", description: "App name to clear cache for" }
+        ],
+        loader: "../maintenance/cacheout.ts",
+        exportName: "cacheout"
+      },
+      {
+        name: "sync-deps",
+        description: "Sync dependencies with dependencies-matrix.json (packages, apps, functions, root)",
+        alias: "sync-dependencies",
+        category: "build",
+        options: [
+          {
+            flags: "-c, --check-only",
+            description: "only check for issues, do not fix"
+          },
+          {
+            flags: "-f, --fix",
+            description: "automatically fix dependency issues"
+          }
+        ],
+        loader: "../bundler/sync-dependencies.ts",
+        exportName: "syncDependencies"
+      },
+      {
+        name: "bump",
+        description: "Update framework packages and peer dependencies to latest compatible versions",
+        category: "build",
+        public: true,
+        loader: "../maintenance/bump.ts",
+        exportName: "bump"
+      },
+      {
+        name: "versions",
+        description: "Check latest npm versions of all @donotdev/* packages",
+        alias: "v",
+        category: "build",
+        loader: "../maintenance/versions.ts"
+      },
+      // ---------------------------------------------------------------------------
+      // Deployment
+      // ---------------------------------------------------------------------------
+      {
+        name: "deploy [app]",
+        description: "Deploy app",
+        category: "deployment",
+        public: true,
+        appCommand: true,
+        options: [
+          { flags: "-p, --project <project>", description: "Firebase project ID" },
+          { flags: "--skip-build", description: "skip build step" },
+          { flags: "--force", description: "Force deployment / cleanup policy" },
+          {
+            flags: "--staging",
+            description: "Deploy to staging (uses .env.staging, service-account-key.staging.json, .firebaserc staging project)"
+          }
+        ],
+        loader: "../apps/deploy.ts",
+        exportName: "deploy"
+      },
+      {
+        name: "staging [app]",
+        description: "Deploy to staging/UAT (shorthand for deploy --staging)",
+        alias: "uat",
+        category: "deployment",
+        public: true,
+        appCommand: true,
+        options: [
+          {
+            flags: "-p, --project <project>",
+            description: "Firebase project ID (overrides .firebaserc)"
+          },
+          { flags: "--skip-build", description: "skip build step" },
+          { flags: "--force", description: "Force deployment / cleanup policy" }
+        ],
+        loader: "../apps/deploy.ts"
+      },
+      {
+        name: "sync-secrets",
+        description: "Sync environment variables to Firebase/Vercel or GitHub Secrets",
+        category: "deployment",
+        public: true,
+        options: [
+          { flags: "-e, --env-file <file>", description: "environment file path" },
+          {
+            flags: "--target <target>",
+            description: "sync target: runtime (default) or github"
+          },
+          {
+            flags: "--platform <platform>",
+            description: "platform (firebase|vercel) for runtime target"
+          },
+          { flags: "-p, --project <project>", description: "project ID" },
+          {
+            flags: "--repo <repo>",
+            description: "GitHub repo (owner/repo) for github target"
+          }
+        ],
+        loader: "../apps/sync-secrets.ts",
+        wrapperFile: "sync-secrets",
+        exportName: "syncSecrets"
+      },
+      {
+        name: "make-admin [userId]",
+        description: "Set a user as admin (custom claims / app_metadata)",
+        alias: "ma",
+        category: "deployment",
+        public: true,
+        options: [
+          {
+            flags: "--project <projectId>",
+            description: "Project ID (Firebase or Supabase)"
+          },
+          {
+            flags: "--project-id <projectId>",
+            description: "Project ID (alias for --project)"
+          },
+          {
+            flags: "--super",
+            description: "Assign super role (isAdmin=true, isSuper=true, role=super)"
+          }
+        ],
+        loader: "../internal/make-admin.ts",
+        wrapperFile: "make-admin",
+        exportName: "makeAdmin"
+      },
+      {
+        name: "coach",
+        description: "Show what to configure before running setup",
+        category: "deployment",
+        public: true,
+        options: [],
+        loader: "../cli/coach/coach.ts",
+        exportName: "coach"
+      },
+      {
+        name: "setup [provider]",
+        description: "Set up infrastructure providers (firebase, supabase, vercel)",
+        category: "deployment",
+        public: true,
+        options: [],
+        loader: "../cli/setup/setup.ts",
+        exportName: "setup"
+      },
+      {
+        name: "setup-cicd",
+        description: "Setup CI/CD configuration",
+        category: "deployment",
+        loader: "../scaffolding/setup-cicd.ts",
+        exportName: "setupCICD"
+      },
+      {
+        name: "soc2",
+        description: "Run SOC2 readiness check \u2014 pass/fail report per Trust Service Criteria",
+        category: "deployment",
+        options: [
+          {
+            flags: "-a, --app <app>",
+            description: "app name to scan (if multiple apps)"
+          },
+          { flags: "--json", description: "output machine-readable JSON report" }
+        ],
+        loader: "../apps/soc2-check.ts",
+        exportName: "soc2Check"
+      },
+      {
+        name: "doctor",
+        description: "Check project health: validate provider connections and .env files",
+        category: "deployment",
+        public: true,
+        options: [
+          {
+            flags: "-c, --check <check>",
+            description: "run a single check (env, firebase, supabase, auth)"
+          }
+        ],
+        loader: "../cli/doctor/doctor.ts",
+        exportName: "doctor"
+      },
+      // ---------------------------------------------------------------------------
+      // Content
+      // ---------------------------------------------------------------------------
+      {
+        name: "blog <source>",
+        description: "Convert source image to optimized WebP for blog (1200px, quality 80)",
+        category: "content",
+        options: [
+          {
+            flags: "--slug <slug>",
+            description: "Output filename (default: source filename)"
+          }
+        ],
+        loader: "../apps/blog.ts"
+      },
+      // ---------------------------------------------------------------------------
+      // Internal
+      // ---------------------------------------------------------------------------
+      {
+        name: "keygen",
+        description: "Generate DoNotDev Framework license keys",
+        alias: "kg",
+        category: "internal",
+        options: [
+          {
+            flags: "--tier <tier>",
+            description: "license tier (dev_seat_1, project_1, etc.)"
+          },
+          {
+            flags: "--count <count>",
+            description: "number of keys to generate (default: 1)"
+          }
+        ],
+        loader: "../utils/keygen.ts",
+        exportName: "keygen"
+      },
+      {
+        name: "add-licenses [userId]",
+        description: "Add licenses to a user account (manual sales, gifts, Stripe fixes)",
+        alias: "al",
+        category: "internal",
+        options: [
+          { flags: "--dev-seats <n>", description: "number of dev seats to add" },
+          { flags: "--projects <n>", description: "number of projects to add" },
+          { flags: "--clean", description: "clean existing licenses first" }
+        ],
+        loader: "../internal/add-licenses.ts"
+      },
+      {
+        name: "grill-review",
+        description: "Interactive review of grill report (.dndev/grill-report.json)",
+        alias: "gr",
+        category: "internal",
+        options: [
+          {
+            flags: "-f, --filter <status>",
+            description: "Filter by status: pending (default), approved, rejected, skipped, all"
+          },
+          {
+            flags: "-s, --severity <level>",
+            description: "Filter by severity: blocker, warn, note"
+          },
+          {
+            flags: "--summary",
+            description: "Show summary only, no interactive review"
+          },
+          {
+            flags: "--export-pairs",
+            description: "Export reviewed items as DPO training pairs to .dndev/dpo-pairs.jsonl"
+          }
+        ],
+        loader: "../quality/grill-review.ts"
+      },
+      {
+        name: "generate sql",
+        description: "Generate PostgreSQL CREATE TABLE + RLS + trigger from entity definitions",
+        category: "internal",
+        options: [
+          {
+            flags: "--entity-dir <dir>",
+            description: "directory containing entity files (default: entities)"
+          },
+          {
+            flags: "--output-dir <dir>",
+            description: "output directory for migrations (default: supabase/migrations)"
+          },
+          {
+            flags: "--no-single-file",
+            description: "emit one migration file per entity"
+          }
+        ],
+        loader: "../generators/sql-generator.ts"
+      },
+      // ---------------------------------------------------------------------------
+      // Other
+      // ---------------------------------------------------------------------------
+      {
+        name: "test",
+        description: "Run tests across packages and apps",
+        category: "other",
+        options: [
+          {
+            flags: "-p, --package <package>",
+            description: "test a specific package (e.g., expo, core)"
+          },
+          { flags: "-a, --app <app>", description: "test a specific app" },
+          { flags: "-w, --watch", description: "run tests in watch mode" },
+          { flags: "-c, --coverage", description: "generate coverage report" },
+          { flags: "--ui", description: "open Vitest UI" },
+          {
+            flags: "--all",
+            description: "run all tests from root (uses root vitest.config.ts)"
+          }
+        ],
+        loader: "../quality/test.ts"
+      },
+      {
+        name: "test:e2e",
+        description: "Run Playwright E2E tests in apps/e2e-test",
+        category: "other",
+        options: [
+          { flags: "--ui", description: "open Playwright UI mode" },
+          { flags: "--headed", description: "run tests in headed browser" }
+        ],
+        loader: "../quality/test-e2e.ts"
+      },
+      {
+        name: "fix-turbo",
+        description: "Fix Turborepo binary platform mismatch (Windows/WSL/Linux)",
+        category: "other",
+        loader: "../maintenance/fix-turbo.ts",
+        exportName: "fixTurbo"
+      },
+      {
+        name: "zof",
+        description: "Nuclear cache clear + fresh bundle + tarball test",
+        category: "other",
+        options: [
+          {
+            flags: "--skip-bundle",
+            description: "Skip bundling (only clear caches)"
+          },
+          {
+            flags: "--skip-test",
+            description: "Skip ../test/ cleanup and reinstall"
+          },
+          {
+            flags: "--cleanup",
+            description: "Clean up tarballs after install (default: keep for testing)"
+          },
+          {
+            flags: "--fast",
+            description: "Fast mode: skip cache clearing (for iterative testing)"
+          }
+        ],
+        loader: "../maintenance/ZeOneOf"
+      },
+      {
+        name: "wai",
+        description: "Output WAI-WAY activation prompt for AI agents",
+        alias: "wai-way",
+        category: "other",
+        public: true,
+        options: [
+          { flags: "-w, --workflow", description: "Show workflow summary only" },
+          { flags: "-c, --copy", description: "Copy prompt to clipboard" }
+        ],
+        loader: "../cli/wai.ts",
+        exportName: "wai"
+      },
+      {
+        name: "agent:setup",
+        description: "Configure local and global agents to connect to the DoNotDev Intelligence Engine (MCP)",
+        category: "other",
+        public: true,
+        wrapperFile: "agent-setup",
+        exportName: "agentSetup",
+        loader: "../cli/agent-setup.ts"
+      }
+    ];
+  }
+});
+
+// packages/cli/src/bin/dndev.mjs
+init_utils();
+init_command_registry();
+import { Command } from "commander";
+
+// packages/tooling/src/cli/entry-helpers.ts
+init_utils();
+function baseName2(commanderName) {
+  return commanderName.split(" ")[0] ?? commanderName;
 }
-var program = new Command();
-program.name("dndev").description("DoNotDev Framework CLI").version(CLI_VERSION, "-v, --version", "display version number").usage("<command>[:<app>] [options]").helpCommand("help [command]", "display help for command");
 function extractCommonOptions(commanderOptions) {
   const quiet = process.env.QUIET === "true" || process.env.QUIET === "1" || commanderOptions.quiet || false;
   const debug = process.env.DEBUG === "true" || process.env.DEBUG === "1" || commanderOptions.debug || false;
   const verbose = !debug && (process.env.VERBOSE === "true" || process.env.VERBOSE === "1" || commanderOptions.verbose || false);
-  const dryRun = process.env.DRY_RUN === "true" || process.env.DRY_RUN === "1" || commanderOptions.dryRun || false;
+  const dryRun = process.env.DRY_RUN === "true" || process.env.DRY_RUN === "1" || commanderOptions.dryRun || commanderOptions.dry || false;
   return { dryRun, quiet, verbose, debug };
 }
 function addCommonOptions(cmd) {
-  cmd.option("-d, --dry-run", "Preview changes without applying").option("--verbose", "Verbose output").option("--debug", "Debug output").option("-q, --quiet", "Quiet output (errors only)");
+  cmd.option("--dry, --dry-run", "Preview changes without applying").option("--verbose", "Verbose output").option("--debug", "Debug output").option("-q, --quiet", "Quiet output (errors only)");
 }
-program.command("init [name]").alias("create-project").description("Create a new DoNotDev project").action(async (name) => {
-  const { main } = await import("./commands/create-project.js");
-  await main({ projectName: name });
-});
-program.command("create-app [name]").description("Add a new app to existing project").option("--name <name>", "App name (non-interactive)").option("--builder <builder>", "Framework: vite, next, or expo (default: vite)").option("--host <host>", "Hosting: none, vercel, or firebase (default: none)").option("--functions <runtime>", "Functions: none, vercel, firebase, or supabase (default: none)").option("--backend <backend>", "BaaS: none, firebase, or supabase (default: none)").option("--project <id>", "Firebase project ID (default: app name)").option("--region <region>", "Firebase region (default: europe-west1)").action(async (name, options) => {
-  const { main } = await import("./commands/create-app.js");
-  const appName = name || options.name;
-  if (appName) {
-    await main({
-      name: appName,
-      builder: options.builder,
-      host: options.host,
-      functions: options.functions,
-      backend: options.backend,
-      firebaseProjectId: options.project,
-      firebaseRegion: options.region
-    });
-  } else {
-    await main();
+function registerCommand(program2, def, action) {
+  const cmd = program2.command(def.name);
+  if (def.alias) {
+    const aliases = Array.isArray(def.alias) ? def.alias : [def.alias];
+    for (const a of aliases) cmd.alias(a);
   }
-});
-var formatCmd = program.command("format").description("Format code with Prettier");
-addCommonOptions(formatCmd);
-formatCmd.action(async (commanderOptions) => {
-  const commonOptions = extractCommonOptions(commanderOptions);
-  const options = { ...commonOptions, ...commanderOptions };
-  try {
-    const { main } = await import("./commands/format.js");
-    process.exitCode = await main(options);
-  } catch (error) {
-    if (error.code === "invalid-argument" || error.name === "DoNotDevError") {
-      process.exit(error.context?.exitCode || 1);
+  cmd.description(def.description);
+  if (def.options) {
+    for (const opt of def.options) {
+      cmd.option(opt.flags, opt.description);
     }
-    throw error;
   }
-});
-var tcCmd = program.command("tc [app]").alias("type-check").description("TypeScript type-check (runs bun run type-check in all packages)");
-addCommonOptions(tcCmd);
-tcCmd.action(async (app, commanderOptions) => {
-  const commonOptions = extractCommonOptions(commanderOptions);
-  const options = { ...commonOptions, app };
-  try {
-    const { main } = await import("./commands/type-check.js");
-    process.exit(await main(options));
-  } catch (error) {
-    if (error.code === "invalid-argument" || error.name === "DoNotDevError") {
-      process.exit(error.context?.exitCode || 1);
-    }
-    throw error;
-  }
-});
-var cacheoutCmd = program.command("cacheout [app]").alias("co").description("Clear build caches").option("--app <app>", "App name to clear cache for");
-addCommonOptions(cacheoutCmd);
-cacheoutCmd.action(async (app, commanderOptions) => {
-  const commonOptions = extractCommonOptions(commanderOptions);
-  const options = { ...commonOptions, ...commanderOptions };
-  if (app) {
-    options.app = app;
-  }
-  const { main } = await import("./commands/cacheout.js");
-  process.exitCode = await main(options);
-});
-var bumpCmd = program.command("bump").description("Update framework packages and peer dependencies to latest compatible versions");
-addCommonOptions(bumpCmd);
-bumpCmd.action(async (commanderOptions) => {
-  const commonOptions = extractCommonOptions(commanderOptions);
-  const options = { ...commonOptions, ...commanderOptions };
-  try {
-    const { main } = await import("./commands/bump.js");
-    process.exitCode = await main(options);
-  } catch (error) {
-    if (error.code === "invalid-argument" || error.name === "DoNotDevError") {
-      process.exit(error.context?.exitCode || 1);
-    }
-    throw error;
-  }
-});
-var stagingCmd = program.command("staging [app]").alias("uat").description("Deploy to staging/UAT (shorthand for deploy --staging)").option("-p, --project <project>", "Firebase project ID (overrides .firebaserc)").option("--skip-build", "skip build step").option("--force", "Force deployment / cleanup policy");
-addCommonOptions(stagingCmd);
-stagingCmd.action(async (app, commanderOptions) => {
-  const commonOptions = extractCommonOptions(commanderOptions);
-  const options = { ...commonOptions, ...commanderOptions, app, staging: true };
-  const { main } = await import("./commands/deploy.js");
-  await main(options);
-});
-var deployCmd = program.command("deploy [app]").description("Deploy to Firebase").option("-p, --project <project>", "Firebase project ID").option("--skip-build", "skip build step").option("--staging", "Deploy to staging (uses .env.staging, service-account-key.staging.json, .firebaserc staging project)");
-addCommonOptions(deployCmd);
-deployCmd.action(async (app, commanderOptions) => {
-  const commonOptions = extractCommonOptions(commanderOptions);
-  const options = { ...commonOptions, ...commanderOptions, app };
-  const { main } = await import("./commands/deploy.js");
-  await main(options);
-});
-var syncSecretsCmd = program.command("sync-secrets").description("Sync env vars to Firebase/Vercel or GitHub Secrets").option("-e, --env-file <file>", "environment file path").option("--target <target>", "sync target: runtime (default) or github").option("--platform <platform>", "platform (firebase|vercel) for runtime target").option("-p, --project <project>", "project ID").option("--repo <repo>", "GitHub repo (owner/repo) for github target");
-addCommonOptions(syncSecretsCmd);
-syncSecretsCmd.action(async (commanderOptions) => {
-  const commonOptions = extractCommonOptions(commanderOptions);
-  const options = { ...commonOptions, ...commanderOptions };
-  if (options.project) {
-    options.projectId = options.project;
-  }
-  const { main } = await import("./commands/sync-secrets.js");
-  process.exitCode = await main(options);
-});
-var makeAdminCmd = program.command("make-admin [userId]").alias("ma").description("Set a user as admin (custom claims / app_metadata)").option("--project <projectId>", "Project ID (Firebase or Supabase)").option("--project-id <projectId>", "Project ID (alias for --project)").option("--super", "Assign super role (isAdmin=true, isSuper=true, role=super)");
-addCommonOptions(makeAdminCmd);
-makeAdminCmd.action(async (userId, commanderOptions) => {
-  const args2 = [];
-  if (userId) args2.push(userId);
-  if (commanderOptions.project) args2.push(`--project=${commanderOptions.project}`);
-  if (commanderOptions.projectId) args2.push(`--project-id=${commanderOptions.projectId}`);
-  if (commanderOptions.super) args2.push("--super");
-  const { main } = await import("./commands/make-admin.js");
-  await main(args2);
-});
-var setupCmd = program.command("setup [provider]").description("Set up provider credentials and connections (firebase, supabase, vercel, stripe, oauth, auth)").option("-a, --app <app>", "app name (if multiple apps)").option("--skip-doctor", "Skip running doctor after setup");
-addCommonOptions(setupCmd);
-setupCmd.action(async (provider, commanderOptions) => {
-  const commonOptions = extractCommonOptions(commanderOptions);
-  const options = { ...commonOptions, provider, app: commanderOptions.app, skipDoctor: commanderOptions.skipDoctor };
-  const { main } = await import("./commands/setup.js");
-  process.exitCode = await main(options);
-});
-var doctorCmd = program.command("doctor").description("Check project health: validate provider connections and .env files").option("-a, --app <app>", "app name (if multiple apps)").option("-c, --check <check>", "run a single check (env, firebase, supabase, stripe, auth)");
-addCommonOptions(doctorCmd);
-doctorCmd.action(async (commanderOptions) => {
-  const commonOptions = extractCommonOptions(commanderOptions);
-  const options = { ...commonOptions, app: commanderOptions.app, check: commanderOptions.check };
-  const { main } = await import("./commands/doctor.js");
-  process.exit(await main(options));
-});
-async function runAppCommand(commandPath, app) {
+  addCommonOptions(cmd);
+  cmd.action(async (...commanderArgs) => {
+    const commanderOptions = commanderArgs[commanderArgs.length - 2];
+    const positionalArgs = commanderArgs.slice(0, -2);
+    const commonOptions = extractCommonOptions(commanderOptions);
+    const parsedOptions = { ...commonOptions, ...commanderOptions };
+    await action(parsedOptions, ...positionalArgs);
+  });
+}
+
+// packages/cli/src/bin/dndev.mjs
+var CLI_VERSION = true ? "0.0.20" : "0.0.0";
+var args = process.argv.slice(2);
+if (args.length === 1 && (args[0] === "--version" || args[0] === "-v")) {
+  console.log(CLI_VERSION);
+  process.exit(0);
+}
+if (args.length === 0 || args.length === 1 && (args[0] === "--help" || args[0] === "-h")) {
+  const { generateHelpText: generateHelpText2 } = await Promise.resolve().then(() => (init_command_registry(), command_registry_exports));
+  console.log(`DoNotDev CLI v${CLI_VERSION}
+`);
+  console.log(generateHelpText2("dndev"));
+  process.exit(0);
+}
+var program = new Command();
+program.name("dndev").description("DoNotDev Framework CLI").version(CLI_VERSION, "-v, --version", "display version number").usage("<command>[:<app>] [options]").helpCommand("help [command]", "display help for command");
+async function runAppCommand(commandPath, app, commonOptions) {
   const savedArgv = process.argv;
   process.argv = app ? [savedArgv[0], savedArgv[1], app] : [savedArgv[0], savedArgv[1]];
   try {
     const { main } = await import(commandPath);
-    process.exit(await main());
+    process.exitCode = await main(commonOptions);
+  } catch (error) {
+    console.error(`Command failed: ${error.message}`);
+    process.exitCode = error.context?.exitCode || 1;
   } finally {
     process.argv = savedArgv;
   }
 }
-program.command("dev [app]").description("Start development server").action((app) => runAppCommand("./commands/dev.js", app));
-program.command("emu [app]").description("Start dev with local backend").action((app) => runAppCommand("./commands/emu.js", app));
-program.command("build [app]").description("Build for production").action((app) => runAppCommand("./commands/build.js", app));
-program.command("preview [app]").description("Preview production build").action((app) => runAppCommand("./commands/preview.js", app));
-program.command("agent").alias("agent:setup").description("Configure MCP server for all AI agents (Cursor, Claude Code, Gemini, Claude Desktop)").option("-d, --dry-run", "Preview changes without applying").action(async (commanderOptions) => {
-  const options = extractCommonOptions(commanderOptions);
-  const { main } = await import("./commands/agent-setup.js");
-  await main(options);
-});
-program.command("wai").alias("wai-way").description("Output WAI-WAY activation prompt for AI agents").option("-w, --workflow", "Show workflow summary only").option("-c, --copy", "Copy prompt to clipboard").action(async () => {
-  const { main } = await import("./commands/wai.js");
-  process.exit(await main());
-});
-function preprocessArgs(args2) {
-  if (args2.length === 0) return args2;
-  const firstArg = args2[0];
-  const appCommands = ["dev", "build", "preview", "emu", "deploy", "staging", "tc", "type-check", "cacheout", "co"];
+function makeStandardAction(commandPath) {
+  return async (options, ...positionalArgs) => {
+    try {
+      const { main } = await import(commandPath);
+      await main(options, ...positionalArgs);
+    } catch (error) {
+      console.error(`Command failed: ${error.message}`);
+      process.exitCode = error.context?.exitCode || 1;
+    }
+  };
+}
+function makeAppAction(commandPath) {
+  return async (options, app) => {
+    await runAppCommand(commandPath, app, extractCommonOptions(options));
+  };
+}
+var ACTION_OVERRIDES = {
+  "create-app": async (options, name) => {
+    const appName = name || options.name;
+    const { main } = await import("./commands/create-app.js");
+    if (appName) {
+      await main({
+        ...options,
+        name: appName
+      });
+    } else {
+      await main(options);
+    }
+  },
+  "type-check": async (options, app) => {
+    const { main } = await import("./commands/type-check.js");
+    process.exitCode = await main({ ...options, package: app });
+  },
+  "cacheout": async (options, app) => {
+    if (app) options.app = app;
+    const { main } = await import("./commands/cacheout.js");
+    process.exitCode = await main(options);
+  },
+  "staging": async (options, app) => {
+    const { main } = await import("./commands/deploy.js");
+    await main({ ...options, app, staging: true });
+  },
+  "deploy": async (options, app) => {
+    const { main } = await import("./commands/deploy.js");
+    await main({ ...options, app });
+  },
+  "sync-secrets": async (options) => {
+    if (options.project) options.projectId = options.project;
+    const { main } = await import("./commands/sync-secrets.js");
+    process.exitCode = await main(options);
+  },
+  "make-admin": async (options, userId) => {
+    const args2 = [];
+    if (userId) args2.push(userId);
+    if (options.project) args2.push(`--project=${options.project}`);
+    if (options.projectId) args2.push(`--project-id=${options.projectId}`);
+    if (options.super) args2.push("--super");
+    if (options.dryRun) args2.push("--dry-run");
+    if (options.verbose) args2.push("--verbose");
+    if (options.debug) args2.push("--debug");
+    try {
+      const { main } = await import("./commands/make-admin.js");
+      await main(args2);
+    } catch (error) {
+      console.error(`make-admin failed: ${error.message}`);
+      process.exitCode = error.context?.exitCode || 1;
+    }
+  },
+  "setup": async (options, provider) => {
+    const { main } = await import("./commands/setup.js");
+    process.exitCode = await main({ ...options, provider });
+  },
+  "doctor": async (options) => {
+    const { main } = await import("./commands/doctor.js");
+    process.exitCode = await main({ ...options, check: options.check });
+  },
+  "wai": async () => {
+    const { main } = await import("./commands/wai.js");
+    process.exitCode = await main();
+  },
+  "agent:setup": async (options) => {
+    const { main } = await import("./commands/agent-setup.js");
+    await main(options);
+  }
+};
+for (const def of getPublicCommands()) {
+  const cmdName = baseName2(def.name);
+  const wrapperFile = def.wrapperFile ?? cmdName;
+  const commandPath = `./commands/${wrapperFile}.js`;
+  const override = ACTION_OVERRIDES[def.name] ?? ACTION_OVERRIDES[cmdName];
+  let action;
+  if (override) {
+    action = override;
+  } else if (def.actionPattern === "app") {
+    action = makeAppAction(commandPath);
+  } else {
+    action = makeStandardAction(commandPath);
+  }
+  registerCommand(program, def, action);
+}
+function preprocessArgs(rawArgs) {
+  if (rawArgs.length === 0) return rawArgs;
+  const firstArg = rawArgs[0];
+  const appCommands = getAppCommandNames();
   if (firstArg && firstArg.includes(":")) {
     const colonIndex = firstArg.indexOf(":");
     const command = firstArg.substring(0, colonIndex);
     const app = firstArg.substring(colonIndex + 1);
     if (appCommands.includes(command) && app) {
-      return [command, app, ...args2.slice(1)];
+      return [command, app, ...rawArgs.slice(1)];
     }
   }
-  return args2;
+  return rawArgs;
 }
 program.on("command:*", () => {
   console.error(`Unknown command: ${program.args.join(" ")}`);