@vexblocks/cli 1.0.0 → 1.0.3

package/dist/index.js

@@ -4,101 +4,12 @@
 import { Command } from "commander";
 import pc6 from "picocolors";
 
-// src/commands/init.ts
+// src/commands/add.ts
 import path4 from "path";
+import { checkbox, confirm } from "@inquirer/prompts";
 import fs4 from "fs-extra";
-import pc2 from "picocolors";
 import ora from "ora";
-import { confirm, input, select } from "@inquirer/prompts";
-
-// src/utils/logger.ts
-import pc from "picocolors";
-var logger = {
-  info: (message) => {
-    console.log(pc.blue("\u2139"), message);
-  },
-  success: (message) => {
-    console.log(pc.green("\u2714"), message);
-  },
-  warn: (message) => {
-    console.log(pc.yellow("\u26A0"), message);
-  },
-  error: (message) => {
-    console.log(pc.red("\u2716"), message);
-  },
-  log: (message) => {
-    console.log(message);
-  },
-  break: () => {
-    console.log();
-  },
-  title: (message) => {
-    console.log();
-    console.log(pc.bold(pc.cyan(message)));
-    console.log();
-  },
-  step: (step, total, message) => {
-    console.log(pc.dim(`[${step}/${total}]`), message);
-  },
-  list: (items) => {
-    for (const item of items) {
-      console.log(pc.dim("  \u2022"), item);
-    }
-  },
-  box: (title, content) => {
-    const maxLength = Math.max(title.length, ...content.map((c) => c.length));
-    const border = "\u2500".repeat(maxLength + 4);
-    console.log();
-    console.log(pc.dim(`\u250C${border}\u2510`));
-    console.log(pc.dim("\u2502"), pc.bold(title.padEnd(maxLength + 2)), pc.dim("\u2502"));
-    console.log(pc.dim(`\u251C${border}\u2524`));
-    for (const line of content) {
-      console.log(pc.dim("\u2502"), line.padEnd(maxLength + 2), pc.dim("\u2502"));
-    }
-    console.log(pc.dim(`\u2514${border}\u2518`));
-    console.log();
-  },
-  code: (code, language) => {
-    console.log();
-    console.log(pc.dim(`\`\`\`${language || ""}`));
-    console.log(code);
-    console.log(pc.dim("```"));
-    console.log();
-  }
-};
-
-// src/utils/fs.ts
-import fs from "fs-extra";
-import path from "path";
-import crypto from "crypto";
-async function isTurborepoProject(cwd) {
-  const turboJsonPath = path.join(cwd, "turbo.json");
-  return fs.pathExists(turboJsonPath);
-}
-async function getPackageManager(cwd) {
-  if (await fs.pathExists(path.join(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (await fs.pathExists(path.join(cwd, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (await fs.pathExists(path.join(cwd, "bun.lockb"))) {
-    return "bun";
-  }
-  return "npm";
-}
-async function createBackup(filePath) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupPath = `${filePath}.backup-${timestamp}`;
-  if (await fs.pathExists(filePath)) {
-    await fs.copy(filePath, backupPath);
-  }
-  return backupPath;
-}
-
-// src/utils/manifest.ts
-import fs2 from "fs-extra";
-import path2 from "path";
+import pc2 from "picocolors";
 
 // src/utils/constants.ts
 var GITHUB_REPO = "vexblocks/vexblocks";
@@ -151,33 +62,38 @@ var OPTIONAL_ENV_VARS = {
   ]
 };
 
-// src/utils/manifest.ts
-async function readManifest(cwd) {
-  const manifestPath = path2.join(cwd, MANIFEST_FILE);
-  try {
-    if (await fs2.pathExists(manifestPath)) {
-      return await fs2.readJson(manifestPath);
-    }
-    return null;
-  } catch {
-    return null;
-  }
+// src/utils/fs.ts
+import crypto from "crypto";
+import path from "path";
+import fs from "fs-extra";
+async function isTurborepoProject(cwd) {
+  const turboJsonPath = path.join(cwd, "turbo.json");
+  return fs.pathExists(turboJsonPath);
 }
-async function writeManifest(cwd, manifest) {
-  const manifestPath = path2.join(cwd, MANIFEST_FILE);
-  await fs2.writeJson(manifestPath, manifest, { spaces: 2 });
+async function getPackageManager(cwd) {
+  if (await fs.pathExists(path.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fs.pathExists(path.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (await fs.pathExists(path.join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  return "npm";
 }
-function createManifest(version) {
-  return {
-    $schema: "https://vexblocks.dev/schema/vexblocks.json",
-    version,
-    packages: {}
-  };
+async function createBackup(filePath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  if (await fs.pathExists(filePath)) {
+    await fs.copy(filePath, backupPath);
+  }
+  return backupPath;
 }
 
 // src/utils/github.ts
-import fs3 from "fs-extra";
-import path3 from "path";
+import path2 from "path";
+import fs2 from "fs-extra";
 async function fetchRemoteManifest() {
   const url = `${GITHUB_RAW_URL}/templates/manifest.json`;
   const response = await fetch(url);
@@ -200,9 +116,9 @@ async function downloadFile(remotePath, localPath) {
   if (!response.ok) {
     throw new Error(`Failed to download ${remotePath}: ${response.statusText}`);
   }
-  await fs3.ensureDir(path3.dirname(localPath));
+  await fs2.ensureDir(path2.dirname(localPath));
   const content = await response.text();
-  await fs3.writeFile(localPath, content, "utf-8");
+  await fs2.writeFile(localPath, content, "utf-8");
 }
 async function downloadAndExtractPackage(packagePath, targetDir, onProgress) {
   const treeUrl = `https://api.github.com/repos/${GITHUB_REPO}/git/trees/${GITHUB_BRANCH}?recursive=1`;
@@ -221,7 +137,7 @@ async function downloadAndExtractPackage(packagePath, targetDir, onProgress) {
   );
   for (const file of files) {
     const relativePath = file.path.slice(packagePath.length + 1);
-    const localPath = path3.join(targetDir, relativePath);
+    const localPath = path2.join(targetDir, relativePath);
     onProgress?.(relativePath);
     await downloadFile(file.path, localPath);
   }
@@ -296,261 +212,98 @@ function compareVersions(a, b) {
   return 0;
 }
 
-// src/commands/init.ts
-async function initCommand(options) {
-  const cwd = options.cwd ? path4.resolve(options.cwd) : process.cwd();
-  logger.title("\u{1F680} VexBlocks CMS Setup");
-  const manifestPath = path4.join(cwd, MANIFEST_FILE);
-  if (await fs4.pathExists(manifestPath)) {
-    logger.warn("VexBlocks is already initialized in this directory.");
-    const continueAnyway = options.yes || await confirm({
-      message: "Do you want to reinitialize?",
-      default: false
-    });
-    if (!continueAnyway) {
-      logger.info("Run `vexblocks add <package>` to add packages.");
-      return;
-    }
-  }
-  const isTurbo = await isTurborepoProject(cwd);
-  let projectType;
-  if (isTurbo) {
-    logger.success("Detected existing Turborepo project");
-    projectType = "existing";
-  } else {
-    projectType = await select({
-      message: "What would you like to do?",
-      choices: [
-        {
-          name: "Create a new Turborepo project with VexBlocks",
-          value: "new"
-        },
-        {
-          name: "Add VexBlocks to this directory (I'll set up Turborepo manually)",
-          value: "existing"
-        }
-      ]
-    });
-  }
-  if (projectType === "new") {
-    await createNewProject(cwd, options);
-  } else {
-    await initializeExisting(cwd, options);
-  }
-}
-async function createNewProject(cwd, options) {
-  const projectName = await input({
-    message: "Project name:",
-    default: path4.basename(cwd),
-    validate: (value) => {
-      if (!value) return "Project name is required";
-      if (!/^[a-z0-9-_]+$/.test(value)) {
-        return "Project name can only contain lowercase letters, numbers, hyphens, and underscores";
-      }
-      return true;
+// src/utils/logger.ts
+import pc from "picocolors";
+var logger = {
+  info: (message) => {
+    console.log(pc.blue("\u2139"), message);
+  },
+  success: (message) => {
+    console.log(pc.green("\u2714"), message);
+  },
+  warn: (message) => {
+    console.log(pc.yellow("\u26A0"), message);
+  },
+  error: (message) => {
+    console.log(pc.red("\u2716"), message);
+  },
+  log: (message) => {
+    console.log(message);
+  },
+  break: () => {
+    console.log();
+  },
+  title: (message) => {
+    console.log();
+    console.log(pc.bold(pc.cyan(message)));
+    console.log();
+  },
+  step: (step, total, message) => {
+    console.log(pc.dim(`[${step}/${total}]`), message);
+  },
+  list: (items) => {
+    for (const item of items) {
+      console.log(pc.dim("  \u2022"), item);
     }
-  });
-  const projectDir = path4.join(cwd, projectName);
-  if (await fs4.pathExists(projectDir)) {
-    const overwrite = await confirm({
-      message: `Directory ${projectName} already exists. Overwrite?`,
-      default: false
-    });
-    if (!overwrite) {
-      logger.info("Aborted.");
-      return;
+  },
+  box: (title, content) => {
+    const maxLength = Math.max(title.length, ...content.map((c) => c.length));
+    const border = "\u2500".repeat(maxLength + 4);
+    console.log();
+    console.log(pc.dim(`\u250C${border}\u2510`));
+    console.log(pc.dim("\u2502"), pc.bold(title.padEnd(maxLength + 2)), pc.dim("\u2502"));
+    console.log(pc.dim(`\u251C${border}\u2524`));
+    for (const line of content) {
+      console.log(pc.dim("\u2502"), line.padEnd(maxLength + 2), pc.dim("\u2502"));
     }
-    await fs4.remove(projectDir);
+    console.log(pc.dim(`\u2514${border}\u2518`));
+    console.log();
+  },
+  code: (code, language) => {
+    console.log();
+    console.log(pc.dim(`\`\`\`${language || ""}`));
+    console.log(code);
+    console.log(pc.dim("```"));
+    console.log();
   }
-  const spinner = ora("Creating project structure...").start();
+};
+
+// src/utils/manifest.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+async function readManifest(cwd) {
+  const manifestPath = path3.join(cwd, MANIFEST_FILE);
   try {
-    await fs4.ensureDir(projectDir);
-    await fs4.ensureDir(path4.join(projectDir, "apps"));
-    await fs4.ensureDir(path4.join(projectDir, "packages"));
-    const packageJson = {
-      name: projectName,
-      version: "0.1.0",
-      private: true,
-      packageManager: "pnpm@9.15.0",
-      workspaces: ["apps/*", "packages/*"],
-      scripts: {
-        dev: "turbo run dev",
-        build: "turbo run build",
-        lint: "turbo run lint",
-        "generate-types": "pnpm --filter @repo/type-generator generate"
-      },
-      devDependencies: {
-        turbo: "^2.6.1"
-      }
-    };
-    await fs4.writeJson(path4.join(projectDir, "package.json"), packageJson, {
-      spaces: 2
-    });
-    const turboJson = {
-      $schema: "https://turbo.build/schema.json",
-      globalDependencies: ["**/.env.*local"],
-      globalEnv: [
-        "CONVEX_DEPLOYMENT",
-        "NEXT_PUBLIC_CONVEX_URL",
-        "NEXT_PUBLIC_CONVEX_SITE_URL",
-        "SITE_URL",
-        "CLOUDFLARE_ACCOUNT_ID",
-        "CLOUDFLARE_SECRET_TOKEN"
-      ],
-      ui: "tui",
-      tasks: {
-        dev: {
-          cache: false,
-          persistent: true
-        },
-        build: {
-          dependsOn: ["^build"],
-          inputs: ["$TURBO_DEFAULT$", ".env*"],
-          outputs: [".next/**", "dist/**"]
-        },
-        lint: {
-          outputs: []
-        }
-      }
-    };
-    await fs4.writeJson(path4.join(projectDir, "turbo.json"), turboJson, {
-      spaces: 2
-    });
-    const pnpmWorkspace = `packages:
-  - "apps/*"
-  - "packages/*"
-`;
-    await fs4.writeFile(
-      path4.join(projectDir, "pnpm-workspace.yaml"),
-      pnpmWorkspace
-    );
-    const gitignore = `# Dependencies
-node_modules
-.pnpm-store
-
-# Build outputs
-dist
-.next
-.turbo
-
-# Environment files
-.env
-.env.local
-.env.*.local
-
-# IDE
-.idea
-.vscode
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Logs
-*.log
-npm-debug.log*
-pnpm-debug.log*
-
-# Convex
-.convex
-`;
-    await fs4.writeFile(path4.join(projectDir, ".gitignore"), gitignore);
-    const envExample = `# Convex
-CONVEX_DEPLOYMENT=
-NEXT_PUBLIC_CONVEX_URL=
-
-# Better Auth
-SITE_URL=http://localhost:3001
-
-# Cloudflare Images (optional, for media library)
-CLOUDFLARE_ACCOUNT_ID=
-CLOUDFLARE_SECRET_TOKEN=
-
-# Revalidation (optional, for ISR)
-REVALIDATE_SECRET=
-FRONTEND_URL=http://localhost:3000
-`;
-    await fs4.writeFile(path4.join(projectDir, ".env.example"), envExample);
-    const version = await getLatestVersion();
-    const manifest = createManifest(version);
-    await writeManifest(projectDir, manifest);
-    spinner.succeed("Project structure created");
-    logger.break();
-    logger.box("\u2705 Project created successfully!", [
-      `Directory: ${pc2.cyan(projectDir)}`,
-      "",
-      pc2.bold("Next steps:"),
-      `1. ${pc2.cyan(`cd ${projectName}`)}`,
-      `2. ${pc2.cyan("pnpm install")}`,
-      `3. ${pc2.cyan("npx vexblocks add all")}`,
-      "4. Set up your Convex project",
-      `5. ${pc2.cyan("pnpm dev")}`
-    ]);
-    const addPackages = options.yes || await confirm({
-      message: "Would you like to add VexBlocks packages now?",
-      default: true
-    });
-    if (addPackages) {
-      logger.break();
-      logger.info(`Run: ${pc2.cyan("npx vexblocks add all")}`);
-      logger.info("After navigating to your project directory.");
+    if (await fs3.pathExists(manifestPath)) {
+      return await fs3.readJson(manifestPath);
     }
-  } catch (error) {
-    spinner.fail("Failed to create project");
-    throw error;
+    return null;
+  } catch {
+    return null;
   }
 }
-async function initializeExisting(cwd, _options) {
-  const spinner = ora("Initializing VexBlocks...").start();
-  try {
-    const hasTurbo = await isTurborepoProject(cwd);
-    if (!hasTurbo) {
-      spinner.warn("No turbo.json found");
-      logger.warn(
-        "VexBlocks requires Turborepo. Please set up Turborepo first."
-      );
-      logger.info(`Run: ${pc2.cyan("npx create-turbo@latest")}`);
-      return;
-    }
-    const version = await getLatestVersion();
-    const manifest = createManifest(version);
-    await writeManifest(cwd, manifest);
-    spinner.succeed("VexBlocks initialized");
-    const packageManager = await getPackageManager(cwd);
-    logger.break();
-    logger.box("\u2705 VexBlocks initialized!", [
-      `Manifest: ${pc2.cyan(MANIFEST_FILE)}`,
-      `Version: ${pc2.cyan(version)}`,
-      "",
-      pc2.bold("Next steps:"),
-      `1. ${pc2.cyan("npx vexblocks add all")} - Add all CMS packages`,
-      "2. Configure your environment variables",
-      `3. ${pc2.cyan(`${packageManager} install`)}`,
-      `4. ${pc2.cyan(`${packageManager === "npm" ? "npm run" : packageManager} dev`)}`
-    ]);
-  } catch (error) {
-    spinner.fail("Failed to initialize");
-    throw error;
-  }
+async function writeManifest(cwd, manifest) {
+  const manifestPath = path3.join(cwd, MANIFEST_FILE);
+  await fs3.writeJson(manifestPath, manifest, { spaces: 2 });
+}
+function createManifest(version) {
+  return {
+    $schema: "https://vexblocks.com/schema/vexblocks.json",
+    version,
+    packages: {}
+  };
 }
 
 // src/commands/add.ts
-import path5 from "path";
-import fs5 from "fs-extra";
-import pc3 from "picocolors";
-import ora2 from "ora";
-import { confirm as confirm2, checkbox } from "@inquirer/prompts";
 var ALL_PACKAGES = ["backend", "shared", "types", "cms"];
 async function addCommand(packages, options) {
-  const cwd = options.cwd ? path5.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path4.resolve(options.cwd) : process.cwd();
   logger.title("\u{1F4E6} Add VexBlocks Packages");
   const isTurbo = await isTurborepoProject(cwd);
   if (!isTurbo) {
     logger.error("This is not a Turborepo project.");
     logger.info(
-      `Run ${pc3.cyan("npx vexblocks init")} first to set up your project.`
+      `Run ${pc2.cyan("npx @vexblocks/cli init")} first to set up your project.`
     );
     process.exit(1);
   }
@@ -600,13 +353,13 @@ async function addCommand(packages, options) {
   const existingPackages = [];
   for (const pkg of resolvedPackages) {
     const targetPath = getPackageTargetPath(cwd, pkg);
-    if (await fs5.pathExists(targetPath)) {
+    if (await fs4.pathExists(targetPath)) {
       existingPackages.push(pkg);
     }
   }
   if (existingPackages.length > 0 && !options.overwrite) {
     logger.warn(`These packages already exist: ${existingPackages.join(", ")}`);
-    const overwrite = options.yes || await confirm2({
+    const overwrite = options.yes || await confirm({
       message: "Overwrite existing packages?",
       default: false
     });
@@ -623,16 +376,16 @@ async function addCommand(packages, options) {
     }
   }
   logger.break();
-  logger.log(pc3.bold("Packages to install:"));
+  logger.log(pc2.bold("Packages to install:"));
   for (const pkg of resolvedPackages) {
     const targetPath = getPackageTargetPath(cwd, pkg);
-    const relativePath = path5.relative(cwd, targetPath);
+    const relativePath = path4.relative(cwd, targetPath);
     logger.log(
-      `  ${pc3.green("+")} ${PACKAGE_NAMES[pkg]} \u2192 ${pc3.dim(relativePath)}`
+      `  ${pc2.green("+")} ${PACKAGE_NAMES[pkg]} \u2192 ${pc2.dim(relativePath)}`
     );
   }
   logger.break();
-  const proceed = options.yes || await confirm2({
+  const proceed = options.yes || await confirm({
     message: "Proceed with installation?",
     default: true
   });
@@ -673,34 +426,34 @@ function resolveDependencies(packages) {
 function getPackageTargetPath(cwd, pkg) {
   switch (pkg) {
     case "cms":
-      return path5.join(cwd, "apps", "cms");
+      return path4.join(cwd, "apps", "cms");
     case "backend":
-      return path5.join(cwd, "packages", "backend");
+      return path4.join(cwd, "packages", "backend");
     case "shared":
-      return path5.join(cwd, "packages", "cms-shared");
+      return path4.join(cwd, "packages", "cms-shared");
     case "types":
-      return path5.join(cwd, "packages", "type-generator");
+      return path4.join(cwd, "packages", "type-generator");
     default:
-      return path5.join(cwd, PACKAGE_PATHS[pkg]);
+      return path4.join(cwd, PACKAGE_PATHS[pkg]);
   }
 }
 async function installPackage(cwd, pkg, version, manifest) {
-  const spinner = ora2(`Installing ${PACKAGE_NAMES[pkg]}...`).start();
+  const spinner = ora(`Installing ${PACKAGE_NAMES[pkg]}...`).start();
   try {
     const targetPath = getPackageTargetPath(cwd, pkg);
     const sourcePath = PACKAGE_PATHS[pkg];
     if (pkg === "backend") {
       await installBackendPackage(targetPath, sourcePath, spinner);
     } else {
-      await fs5.ensureDir(targetPath);
+      await fs4.ensureDir(targetPath);
       await downloadAndExtractPackage(sourcePath, targetPath, (file) => {
-        spinner.text = `Installing ${PACKAGE_NAMES[pkg]}... ${pc3.dim(file)}`;
+        spinner.text = `Installing ${PACKAGE_NAMES[pkg]}... ${pc2.dim(file)}`;
       });
     }
     const config = {
       version,
       installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      path: path5.relative(cwd, targetPath)
+      path: path4.relative(cwd, targetPath)
     };
     manifest.packages[pkg] = config;
     spinner.succeed(`Installed ${PACKAGE_NAMES[pkg]}`);
@@ -710,14 +463,14 @@ async function installPackage(cwd, pkg, version, manifest) {
   }
 }
 async function installBackendPackage(targetPath, sourcePath, spinner) {
-  const convexPath = path5.join(targetPath, "convex");
-  const existingSchemaPath = path5.join(convexPath, "schema.ts");
-  const hasSchema = await fs5.pathExists(existingSchemaPath);
+  const convexPath = path4.join(targetPath, "convex");
+  const existingSchemaPath = path4.join(convexPath, "schema.ts");
+  const hasSchema = await fs4.pathExists(existingSchemaPath);
   if (hasSchema) {
     spinner.text = "Detected existing Convex schema, merging CMS tables...";
     const backupPath = `${existingSchemaPath}.backup-${Date.now()}`;
-    await fs5.copy(existingSchemaPath, backupPath);
-    logger.info(`Backed up existing schema to ${path5.basename(backupPath)}`);
+    await fs4.copy(existingSchemaPath, backupPath);
+    logger.info(`Backed up existing schema to ${path4.basename(backupPath)}`);
     const cmsFiles = [
       "convex/cms",
       "convex/schema.cms.ts",
@@ -730,15 +483,15 @@ async function installBackendPackage(targetPath, sourcePath, spinner) {
     ];
     for (const file of cmsFiles) {
       const fullSourcePath = `${sourcePath}/${file}`;
-      const fullTargetPath = path5.join(targetPath, file);
+      const fullTargetPath = path4.join(targetPath, file);
       spinner.text = `Downloading ${file}...`;
       try {
         await downloadAndExtractPackage(fullSourcePath, fullTargetPath);
       } catch {
         try {
           const content = await fetchFile(fullSourcePath);
-          await fs5.ensureDir(path5.dirname(fullTargetPath));
-          await fs5.writeFile(fullTargetPath, content);
+          await fs4.ensureDir(path4.dirname(fullTargetPath));
+          await fs4.writeFile(fullTargetPath, content);
         } catch {
         }
       }
@@ -756,14 +509,14 @@ async function installBackendPackage(targetPath, sourcePath, spinner) {
 // })
 // === END VEXBLOCKS CMS ===
 `;
-    const existingContent = await fs5.readFile(existingSchemaPath, "utf-8");
+    const existingContent = await fs4.readFile(existingSchemaPath, "utf-8");
     if (!existingContent.includes("VEXBLOCKS CMS")) {
-      await fs5.appendFile(existingSchemaPath, schemaInstructions);
+      await fs4.appendFile(existingSchemaPath, schemaInstructions);
     }
   } else {
-    await fs5.ensureDir(targetPath);
+    await fs4.ensureDir(targetPath);
     await downloadAndExtractPackage(sourcePath, targetPath, (file) => {
-      spinner.text = `Installing backend... ${pc3.dim(file)}`;
+      spinner.text = `Installing backend... ${pc2.dim(file)}`;
     });
   }
 }
@@ -772,28 +525,28 @@ function showNextSteps(packages) {
   logger.break();
   logger.box("\u2705 Packages installed successfully!", [
     "",
-    pc3.bold("Next steps:"),
+    pc2.bold("Next steps:"),
     "",
-    `1. Install dependencies: ${pc3.cyan(`${packageManager} install`)}`,
+    `1. Install dependencies: ${pc2.cyan(`${packageManager} install`)}`,
     "",
     "2. Set up environment variables:",
-    ...getRequiredEnvVars(packages).map((v) => `   ${pc3.dim(v)}`),
+    ...getRequiredEnvVars(packages).map((v) => `   ${pc2.dim(v)}`),
     "",
     "3. Set up Convex (if not already):",
-    `   ${pc3.cyan("npx convex dev")} in packages/backend`,
+    `   ${pc2.cyan("npx convex dev")} in packages/backend`,
     "",
     "4. Start development:",
-    `   ${pc3.cyan(`${packageManager} dev`)}`,
+    `   ${pc2.cyan(`${packageManager} dev`)}`,
     "",
-    pc3.dim("CMS will be available at http://localhost:3001")
+    pc2.dim("CMS will be available at http://localhost:3001")
   ]);
   const optionalVars = getOptionalEnvVars(packages);
   if (optionalVars.length > 0) {
     logger.break();
-    logger.log(pc3.bold("Optional environment variables:"));
+    logger.log(pc2.bold("Optional environment variables:"));
     for (const { name, description } of optionalVars) {
-      logger.log(`  ${pc3.yellow(name)}`);
-      logger.log(`    ${pc3.dim(description)}`);
+      logger.log(`  ${pc2.yellow(name)}`);
+      logger.log(`    ${pc2.dim(description)}`);
     }
   }
 }
@@ -822,219 +575,50 @@ function getOptionalEnvVars(packages) {
   return vars;
 }
 
-// src/commands/upgrade.ts
-import path6 from "path";
-import fs6 from "fs-extra";
-import pc4 from "picocolors";
-import ora3 from "ora";
-import { confirm as confirm3 } from "@inquirer/prompts";
-async function upgradeCommand(packages, options) {
-  const cwd = options.cwd ? path6.resolve(options.cwd) : process.cwd();
-  logger.title("\u2B06\uFE0F  Upgrade VexBlocks Packages");
+// src/commands/diff.ts
+import path5 from "path";
+import { createTwoFilesPatch } from "diff";
+import fs5 from "fs-extra";
+import ora2 from "ora";
+import pc3 from "picocolors";
+async function diffCommand(packageArg, options) {
+  const cwd = options.cwd ? path5.resolve(options.cwd) : process.cwd();
+  logger.title("\u{1F50D} VexBlocks Diff");
   const manifest = await readManifest(cwd);
   if (!manifest) {
-    logger.error("No vexblocks.json found. Run `vexblocks init` first.");
+    logger.error("No vexblocks.json found. Run `npx @vexblocks/cli init` first.");
     process.exit(1);
   }
-  const spinner = ora3("Checking for updates...").start();
-  const latestVersion = await getLatestVersion();
-  spinner.stop();
   const installedPackages = Object.keys(manifest.packages);
   if (installedPackages.length === 0) {
-    logger.info("No packages installed. Run `vexblocks add <package>` first.");
+    logger.info("No packages installed.");
     return;
   }
-  let packagesToUpgrade;
-  if (packages.length === 0) {
-    packagesToUpgrade = installedPackages;
-  } else {
-    packagesToUpgrade = packages.filter(
-      (p) => installedPackages.includes(p)
-    );
-    if (packagesToUpgrade.length === 0) {
-      logger.error("None of the specified packages are installed.");
+  let packageToDiff;
+  if (packageArg) {
+    if (!installedPackages.includes(packageArg)) {
+      logger.error(`Package "${packageArg}" is not installed.`);
+      logger.info(`Installed packages: ${installedPackages.join(", ")}`);
       return;
     }
-  }
-  const updates = [];
-  for (const pkg of packagesToUpgrade) {
-    const config = manifest.packages[pkg];
-    if (!config) continue;
-    const comparison = compareVersions(config.version, latestVersion);
-    if (comparison < 0) {
-      updates.push({
-        pkg,
-        from: config.version,
-        to: latestVersion
-      });
-    }
-  }
-  if (updates.length === 0) {
-    logger.success("All packages are up to date!");
-    logger.info(`Current version: ${pc4.cyan(latestVersion)}`);
-    return;
-  }
-  logger.log(pc4.bold("\nAvailable updates:"));
-  logger.break();
-  for (const update of updates) {
-    const isManaged = MANAGED_PACKAGES.includes(update.pkg);
-    logger.log(
-      `  ${PACKAGE_NAMES[update.pkg]}`,
-      pc4.dim(`${update.from} \u2192 `),
-      pc4.green(update.to),
-      isManaged ? pc4.yellow(" (managed)") : ""
-    );
-  }
-  const changelog = await getChangelog(updates[0].from, latestVersion);
-  if (Object.keys(changelog).length > 0) {
-    logger.break();
-    logger.log(pc4.bold("Changelog:"));
-    for (const [version, changes] of Object.entries(changelog)) {
-      logger.log(`
-  ${pc4.cyan(version)}`);
-      for (const change of changes) {
-        logger.log(`    ${pc4.dim("\u2022")} ${change}`);
-      }
-    }
-  }
-  if (options.check) {
-    logger.break();
-    logger.info(
-      `Run ${pc4.cyan("npx vexblocks upgrade")} to apply these updates.`
-    );
-    return;
-  }
-  logger.break();
-  const proceed = options.yes || await confirm3({
-    message: `Upgrade ${updates.length} package(s)?`,
-    default: true
-  });
-  if (!proceed) {
-    logger.info("Aborted.");
+    packageToDiff = packageArg;
+  } else if (installedPackages.length === 1) {
+    packageToDiff = installedPackages[0];
+  } else {
+    logger.error("Please specify a package to diff.");
+    logger.info(`Usage: ${pc3.cyan("vexblocks diff <package>")}`);
+    logger.info(`Installed packages: ${installedPackages.join(", ")}`);
     return;
   }
-  for (const update of updates) {
-    await upgradePackage(cwd, update.pkg, update.to, manifest, options);
-  }
-  manifest.version = latestVersion;
-  await writeManifest(cwd, manifest);
-  logger.break();
-  logger.success(`Upgraded to version ${pc4.cyan(latestVersion)}`);
-  logger.info(
-    "Run your package manager's install command to update dependencies."
-  );
-}
-async function upgradePackage(cwd, pkg, version, manifest, options) {
-  const spinner = ora3(`Upgrading ${PACKAGE_NAMES[pkg]}...`).start();
+  const spinner = ora2(`Comparing ${PACKAGE_NAMES[packageToDiff]}...`).start();
   try {
-    const config = manifest.packages[pkg];
+    const config = manifest.packages[packageToDiff];
     if (!config) {
-      spinner.skip(`${PACKAGE_NAMES[pkg]} not installed`);
-      return;
-    }
-    const targetPath = path6.join(cwd, config.path);
-    if (!await fs6.pathExists(targetPath)) {
-      spinner.warn(
-        `${PACKAGE_NAMES[pkg]} directory not found at ${config.path}`
-      );
+      spinner.fail("Package configuration not found");
       return;
     }
-    const isManaged = MANAGED_PACKAGES.includes(pkg);
-    if (isManaged || options.force) {
-      const backupPath = await createBackup(targetPath);
-      spinner.text = `Created backup at ${path6.basename(backupPath)}`;
-      await fs6.remove(targetPath);
-      const sourcePath = getSourcePath(pkg);
-      await downloadAndExtractPackage(sourcePath, targetPath, (file) => {
-        spinner.text = `Upgrading ${PACKAGE_NAMES[pkg]}... ${pc4.dim(file)}`;
-      });
-    } else {
-      spinner.text = `Upgrading CMS files in ${PACKAGE_NAMES[pkg]}...`;
-      const cmsFiles = ["convex/cms", "convex/schema.cms.ts"];
-      for (const file of cmsFiles) {
-        const targetFilePath = path6.join(targetPath, file);
-        const sourceFilePath = `packages/backend/${file}`;
-        if (await fs6.pathExists(targetFilePath)) {
-          await createBackup(targetFilePath);
-        }
-        try {
-          await fs6.remove(targetFilePath);
-          await downloadAndExtractPackage(sourceFilePath, targetFilePath);
-        } catch {
-        }
-      }
-    }
-    const newConfig = {
-      ...config,
-      version,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    manifest.packages[pkg] = newConfig;
-    spinner.succeed(`Upgraded ${PACKAGE_NAMES[pkg]} to ${version}`);
-  } catch (error) {
-    spinner.fail(`Failed to upgrade ${PACKAGE_NAMES[pkg]}`);
-    throw error;
-  }
-}
-function getSourcePath(pkg) {
-  switch (pkg) {
-    case "cms":
-      return "apps/cms";
-    case "backend":
-      return "packages/backend";
-    case "shared":
-      return "packages/cms-shared";
-    case "types":
-      return "packages/type-generator";
-    default:
-      throw new Error(`Unknown package: ${pkg}`);
-  }
-}
-
-// src/commands/diff.ts
-import path7 from "path";
-import fs7 from "fs-extra";
-import pc5 from "picocolors";
-import ora4 from "ora";
-import { createTwoFilesPatch } from "diff";
-async function diffCommand(packageArg, options) {
-  const cwd = options.cwd ? path7.resolve(options.cwd) : process.cwd();
-  logger.title("\u{1F50D} VexBlocks Diff");
-  const manifest = await readManifest(cwd);
-  if (!manifest) {
-    logger.error("No vexblocks.json found. Run `vexblocks init` first.");
-    process.exit(1);
-  }
-  const installedPackages = Object.keys(manifest.packages);
-  if (installedPackages.length === 0) {
-    logger.info("No packages installed.");
-    return;
-  }
-  let packageToDiff;
-  if (packageArg) {
-    if (!installedPackages.includes(packageArg)) {
-      logger.error(`Package "${packageArg}" is not installed.`);
-      logger.info(`Installed packages: ${installedPackages.join(", ")}`);
-      return;
-    }
-    packageToDiff = packageArg;
-  } else if (installedPackages.length === 1) {
-    packageToDiff = installedPackages[0];
-  } else {
-    logger.error("Please specify a package to diff.");
-    logger.info(`Usage: ${pc5.cyan("vexblocks diff <package>")}`);
-    logger.info(`Installed packages: ${installedPackages.join(", ")}`);
-    return;
-  }
-  const spinner = ora4(`Comparing ${PACKAGE_NAMES[packageToDiff]}...`).start();
-  try {
-    const config = manifest.packages[packageToDiff];
-    if (!config) {
-      spinner.fail("Package configuration not found");
-      return;
-    }
-    const localPath = path7.join(cwd, config.path);
-    const remotePath = getSourcePath2(packageToDiff);
+    const localPath = path5.join(cwd, config.path);
+    const remotePath = getSourcePath(packageToDiff);
     const remoteFiles = await getPackageFiles(remotePath);
     let totalDiffs = 0;
     let newFiles = 0;
@@ -1042,12 +626,12 @@ async function diffCommand(packageArg, options) {
     let deletedFiles = 0;
     spinner.stop();
     for (const file of remoteFiles) {
-      const localFilePath = path7.join(localPath, file);
+      const localFilePath = path5.join(localPath, file);
       const remoteFilePath = `${remotePath}/${file}`;
       let localContent = "";
       let remoteContent = "";
-      if (await fs7.pathExists(localFilePath)) {
-        localContent = await fs7.readFile(localFilePath, "utf-8");
+      if (await fs5.pathExists(localFilePath)) {
+        localContent = await fs5.readFile(localFilePath, "utf-8");
       }
       try {
         remoteContent = await fetchFile(remoteFilePath);
@@ -1057,11 +641,11 @@ async function diffCommand(packageArg, options) {
       if (!localContent && remoteContent) {
         newFiles++;
         totalDiffs++;
-        logger.log(`${pc5.green("+")} ${file} ${pc5.dim("(new file)")}`);
+        logger.log(`${pc3.green("+")} ${file} ${pc3.dim("(new file)")}`);
       } else if (localContent !== remoteContent) {
         modifiedFiles++;
         totalDiffs++;
-        logger.log(`${pc5.yellow("~")} ${file} ${pc5.dim("(modified)")}`);
+        logger.log(`${pc3.yellow("~")} ${file} ${pc3.dim("(modified)")}`);
         const patch = createTwoFilesPatch(
           `local/${file}`,
           `remote/${file}`,
@@ -1075,14 +659,14 @@ async function diffCommand(packageArg, options) {
         let lineCount = 0;
         for (const line of lines) {
           if (lineCount >= maxLines) {
-            logger.log(pc5.dim(`  ... (${lines.length - maxLines} more lines)`));
+            logger.log(pc3.dim(`  ... (${lines.length - maxLines} more lines)`));
             break;
           }
           if (line.startsWith("+") && !line.startsWith("+++")) {
-            logger.log(pc5.green(`  ${line}`));
+            logger.log(pc3.green(`  ${line}`));
             lineCount++;
           } else if (line.startsWith("-") && !line.startsWith("---")) {
-            logger.log(pc5.red(`  ${line}`));
+            logger.log(pc3.red(`  ${line}`));
             lineCount++;
           }
         }
@@ -1097,7 +681,7 @@ async function diffCommand(packageArg, options) {
         }
         deletedFiles++;
         totalDiffs++;
-        logger.log(`${pc5.red("-")} ${file} ${pc5.dim("(deleted in remote)")}`);
+        logger.log(`${pc3.red("-")} ${file} ${pc3.dim("(deleted in remote)")}`);
       }
     }
     logger.break();
@@ -1106,15 +690,15 @@ async function diffCommand(packageArg, options) {
         "No differences found. Local files match the latest version."
       );
     } else {
-      logger.log(pc5.bold("Summary:"));
-      if (newFiles > 0) logger.log(`  ${pc5.green(`+${newFiles}`)} new files`);
+      logger.log(pc3.bold("Summary:"));
+      if (newFiles > 0) logger.log(`  ${pc3.green(`+${newFiles}`)} new files`);
       if (modifiedFiles > 0)
-        logger.log(`  ${pc5.yellow(`~${modifiedFiles}`)} modified files`);
+        logger.log(`  ${pc3.yellow(`~${modifiedFiles}`)} modified files`);
       if (deletedFiles > 0)
-        logger.log(`  ${pc5.red(`-${deletedFiles}`)} files removed in remote`);
+        logger.log(`  ${pc3.red(`-${deletedFiles}`)} files removed in remote`);
       logger.break();
       logger.info(
-        `Run ${pc5.cyan("npx vexblocks upgrade")} to update to the latest version.`
+        `Run ${pc3.cyan("npx @vexblocks/cli upgrade")} to update to the latest version.`
       );
     }
   } catch (error) {
@@ -1122,7 +706,7 @@ async function diffCommand(packageArg, options) {
     throw error;
   }
 }
-function getSourcePath2(pkg) {
+function getSourcePath(pkg) {
   switch (pkg) {
     case "cms":
       return "apps/cms";
@@ -1138,10 +722,10 @@ function getSourcePath2(pkg) {
 }
 async function getLocalFiles(dir, base = "") {
   const files = [];
-  if (!await fs7.pathExists(dir)) {
+  if (!await fs5.pathExists(dir)) {
     return files;
   }
-  const entries = await fs7.readdir(dir, { withFileTypes: true });
+  const entries = await fs5.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const relativePath = base ? `${base}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
@@ -1149,7 +733,7 @@ async function getLocalFiles(dir, base = "") {
         continue;
       }
       const subFiles = await getLocalFiles(
-        path7.join(dir, entry.name),
+        path5.join(dir, entry.name),
         relativePath
       );
       files.push(...subFiles);
@@ -1160,10 +744,422 @@ async function getLocalFiles(dir, base = "") {
   return files;
 }
 
+// src/commands/init.ts
+import path6 from "path";
+import { confirm as confirm2, input, select } from "@inquirer/prompts";
+import fs6 from "fs-extra";
+import ora3 from "ora";
+import pc4 from "picocolors";
+async function initCommand(options) {
+  const cwd = options.cwd ? path6.resolve(options.cwd) : process.cwd();
+  logger.title("\u{1F680} VexBlocks CMS Setup");
+  const manifestPath = path6.join(cwd, MANIFEST_FILE);
+  if (await fs6.pathExists(manifestPath)) {
+    logger.warn("VexBlocks is already initialized in this directory.");
+    const continueAnyway = options.yes || await confirm2({
+      message: "Do you want to reinitialize?",
+      default: false
+    });
+    if (!continueAnyway) {
+      logger.info("Run `npx @vexblocks/cli add <package>` to add packages.");
+      return;
+    }
+  }
+  const isTurbo = await isTurborepoProject(cwd);
+  let projectType;
+  if (isTurbo) {
+    logger.success("Detected existing Turborepo project");
+    projectType = "existing";
+  } else {
+    projectType = await select({
+      message: "What would you like to do?",
+      choices: [
+        {
+          name: "Create a new Turborepo project with VexBlocks",
+          value: "new"
+        },
+        {
+          name: "Add VexBlocks to this directory (I'll set up Turborepo manually)",
+          value: "existing"
+        }
+      ]
+    });
+  }
+  if (projectType === "new") {
+    await createNewProject(cwd, options);
+  } else {
+    await initializeExisting(cwd, options);
+  }
+}
+async function createNewProject(cwd, options) {
+  const projectName = await input({
+    message: "Project name:",
+    default: path6.basename(cwd),
+    validate: (value) => {
+      if (!value) return "Project name is required";
+      if (!/^[a-z0-9-_]+$/.test(value)) {
+        return "Project name can only contain lowercase letters, numbers, hyphens, and underscores";
+      }
+      return true;
+    }
+  });
+  const projectDir = path6.join(cwd, projectName);
+  if (await fs6.pathExists(projectDir)) {
+    const overwrite = await confirm2({
+      message: `Directory ${projectName} already exists. Overwrite?`,
+      default: false
+    });
+    if (!overwrite) {
+      logger.info("Aborted.");
+      return;
+    }
+    await fs6.remove(projectDir);
+  }
+  const spinner = ora3("Creating project structure...").start();
+  try {
+    await fs6.ensureDir(projectDir);
+    await fs6.ensureDir(path6.join(projectDir, "apps"));
+    await fs6.ensureDir(path6.join(projectDir, "packages"));
+    const packageJson = {
+      name: projectName,
+      version: "0.1.0",
+      private: true,
+      packageManager: "pnpm@9.15.0",
+      workspaces: ["apps/*", "packages/*"],
+      scripts: {
+        dev: "turbo run dev",
+        build: "turbo run build",
+        lint: "turbo run lint",
+        "generate-types": "pnpm --filter @repo/type-generator generate"
+      },
+      devDependencies: {
+        turbo: "^2.6.1"
+      }
+    };
+    await fs6.writeJson(path6.join(projectDir, "package.json"), packageJson, {
+      spaces: 2
+    });
+    const turboJson = {
+      $schema: "https://turbo.build/schema.json",
+      globalDependencies: ["**/.env.*local"],
+      globalEnv: [
+        "CONVEX_DEPLOYMENT",
+        "NEXT_PUBLIC_CONVEX_URL",
+        "NEXT_PUBLIC_CONVEX_SITE_URL",
+        "SITE_URL",
+        "CLOUDFLARE_ACCOUNT_ID",
+        "CLOUDFLARE_SECRET_TOKEN"
+      ],
+      ui: "tui",
+      tasks: {
+        dev: {
+          cache: false,
+          persistent: true
+        },
+        build: {
+          dependsOn: ["^build"],
+          inputs: ["$TURBO_DEFAULT$", ".env*"],
+          outputs: [".next/**", "dist/**"]
+        },
+        lint: {
+          outputs: []
+        }
+      }
+    };
+    await fs6.writeJson(path6.join(projectDir, "turbo.json"), turboJson, {
+      spaces: 2
+    });
+    const pnpmWorkspace = `packages:
+  - "apps/*"
+  - "packages/*"
+`;
+    await fs6.writeFile(
+      path6.join(projectDir, "pnpm-workspace.yaml"),
+      pnpmWorkspace
+    );
+    const gitignore = `# Dependencies
+node_modules
+.pnpm-store
+
+# Build outputs
+dist
+.next
+.turbo
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea
+.vscode
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+# Convex
+.convex
+`;
+    await fs6.writeFile(path6.join(projectDir, ".gitignore"), gitignore);
+    const envExample = `# Convex
+CONVEX_DEPLOYMENT=
+NEXT_PUBLIC_CONVEX_URL=
+
+# Better Auth
+SITE_URL=http://localhost:3001
+
+# Cloudflare Images (optional, for media library)
+CLOUDFLARE_ACCOUNT_ID=
+CLOUDFLARE_SECRET_TOKEN=
+
+# Revalidation (optional, for ISR)
+REVALIDATE_SECRET=
+FRONTEND_URL=http://localhost:3000
+`;
+    await fs6.writeFile(path6.join(projectDir, ".env.example"), envExample);
+    const version = await getLatestVersion();
+    const manifest = createManifest(version);
+    await writeManifest(projectDir, manifest);
+    spinner.succeed("Project structure created");
+    logger.break();
+    logger.box("\u2705 Project created successfully!", [
+      `Directory: ${pc4.cyan(projectDir)}`,
+      "",
+      pc4.bold("Next steps:"),
+      `1. ${pc4.cyan(`cd ${projectName}`)}`,
+      `2. ${pc4.cyan("pnpm install")}`,
+      `3. ${pc4.cyan("npx @vexblocks/cli add all")}`,
+      "4. Set up your Convex project",
+      `5. ${pc4.cyan("pnpm dev")}`
+    ]);
+    const addPackages = options.yes || await confirm2({
+      message: "Would you like to add VexBlocks packages now?",
+      default: true
+    });
+    if (addPackages) {
+      logger.break();
+      logger.info(`Run: ${pc4.cyan("npx @vexblocks/cli add all")}`);
+      logger.info("After navigating to your project directory.");
+    }
+  } catch (error) {
+    spinner.fail("Failed to create project");
+    throw error;
+  }
+}
+async function initializeExisting(cwd, _options) {
+  const spinner = ora3("Initializing VexBlocks...").start();
+  try {
+    const hasTurbo = await isTurborepoProject(cwd);
+    if (!hasTurbo) {
+      spinner.warn("No turbo.json found");
+      logger.warn(
+        "VexBlocks requires Turborepo. Please set up Turborepo first."
+      );
+      logger.info(`Run: ${pc4.cyan("npx create-turbo@latest")}`);
+      return;
+    }
+    const version = await getLatestVersion();
+    const manifest = createManifest(version);
+    await writeManifest(cwd, manifest);
+    spinner.succeed("VexBlocks initialized");
+    const packageManager = await getPackageManager(cwd);
+    logger.break();
+    logger.box("\u2705 VexBlocks initialized!", [
+      `Manifest: ${pc4.cyan(MANIFEST_FILE)}`,
+      `Version: ${pc4.cyan(version)}`,
+      "",
+      pc4.bold("Next steps:"),
+      `1. ${pc4.cyan("npx @vexblocks/cli add all")} - Add all CMS packages`,
+      "2. Configure your environment variables",
+      `3. ${pc4.cyan(`${packageManager} install`)}`,
+      `4. ${pc4.cyan(`${packageManager === "npm" ? "npm run" : packageManager} dev`)}`
+    ]);
+  } catch (error) {
+    spinner.fail("Failed to initialize");
+    throw error;
+  }
+}
+
+// src/commands/upgrade.ts
+import path7 from "path";
+import { confirm as confirm3 } from "@inquirer/prompts";
+import fs7 from "fs-extra";
+import ora4 from "ora";
+import pc5 from "picocolors";
+async function upgradeCommand(packages, options) {
+  const cwd = options.cwd ? path7.resolve(options.cwd) : process.cwd();
+  logger.title("\u2B06\uFE0F  Upgrade VexBlocks Packages");
+  const manifest = await readManifest(cwd);
+  if (!manifest) {
+    logger.error("No vexblocks.json found. Run `npx @vexblocks/cli init` first.");
+    process.exit(1);
+  }
+  const spinner = ora4("Checking for updates...").start();
+  const latestVersion = await getLatestVersion();
+  spinner.stop();
+  const installedPackages = Object.keys(manifest.packages);
+  if (installedPackages.length === 0) {
+    logger.info("No packages installed. Run `npx @vexblocks/cli add <package>` first.");
+    return;
+  }
+  let packagesToUpgrade;
+  if (packages.length === 0) {
+    packagesToUpgrade = installedPackages;
+  } else {
+    packagesToUpgrade = packages.filter(
+      (p) => installedPackages.includes(p)
+    );
+    if (packagesToUpgrade.length === 0) {
+      logger.error("None of the specified packages are installed.");
+      return;
+    }
+  }
+  const updates = [];
+  for (const pkg of packagesToUpgrade) {
+    const config = manifest.packages[pkg];
+    if (!config) continue;
+    const comparison = compareVersions(config.version, latestVersion);
+    if (comparison < 0) {
+      updates.push({
+        pkg,
+        from: config.version,
+        to: latestVersion
+      });
+    }
+  }
+  if (updates.length === 0) {
+    logger.success("All packages are up to date!");
+    logger.info(`Current version: ${pc5.cyan(latestVersion)}`);
+    return;
+  }
+  logger.log(pc5.bold("\nAvailable updates:"));
+  logger.break();
+  for (const update of updates) {
+    const isManaged = MANAGED_PACKAGES.includes(update.pkg);
+    const managedLabel = isManaged ? pc5.yellow(" (managed)") : "";
+    logger.log(
+      `  ${PACKAGE_NAMES[update.pkg]} ${pc5.dim(`${update.from} \u2192 `)}${pc5.green(update.to)}${managedLabel}`
+    );
+  }
+  const changelog = await getChangelog(updates[0].from, latestVersion);
+  if (Object.keys(changelog).length > 0) {
+    logger.break();
+    logger.log(pc5.bold("Changelog:"));
+    for (const [version, changes] of Object.entries(changelog)) {
+      logger.log(`
+  ${pc5.cyan(version)}`);
+      for (const change of changes) {
+        logger.log(`    ${pc5.dim("\u2022")} ${change}`);
+      }
+    }
+  }
+  if (options.check) {
+    logger.break();
+    logger.info(
+      `Run ${pc5.cyan("npx @vexblocks/cli upgrade")} to apply these updates.`
+    );
+    return;
+  }
+  logger.break();
+  const proceed = options.yes || await confirm3({
+    message: `Upgrade ${updates.length} package(s)?`,
+    default: true
+  });
+  if (!proceed) {
+    logger.info("Aborted.");
+    return;
+  }
+  for (const update of updates) {
+    await upgradePackage(cwd, update.pkg, update.to, manifest, options);
+  }
+  manifest.version = latestVersion;
+  await writeManifest(cwd, manifest);
+  logger.break();
+  logger.success(`Upgraded to version ${pc5.cyan(latestVersion)}`);
+  logger.info(
+    "Run your package manager's install command to update dependencies."
+  );
+}
+async function upgradePackage(cwd, pkg, version, manifest, options) {
+  const spinner = ora4(`Upgrading ${PACKAGE_NAMES[pkg]}...`).start();
+  try {
+    const config = manifest.packages[pkg];
+    if (!config) {
+      spinner.info(`${PACKAGE_NAMES[pkg]} not installed`);
+      return;
+    }
+    const targetPath = path7.join(cwd, config.path);
+    if (!await fs7.pathExists(targetPath)) {
+      spinner.warn(
+        `${PACKAGE_NAMES[pkg]} directory not found at ${config.path}`
+      );
+      return;
+    }
+    const isManaged = MANAGED_PACKAGES.includes(pkg);
+    if (isManaged || options.force) {
+      const backupPath = await createBackup(targetPath);
+      spinner.text = `Created backup at ${path7.basename(backupPath)}`;
+      await fs7.remove(targetPath);
+      const sourcePath = getSourcePath2(pkg);
+      await downloadAndExtractPackage(sourcePath, targetPath, (file) => {
+        spinner.text = `Upgrading ${PACKAGE_NAMES[pkg]}... ${pc5.dim(file)}`;
+      });
+    } else {
+      spinner.text = `Upgrading CMS files in ${PACKAGE_NAMES[pkg]}...`;
+      const cmsFiles = ["convex/cms", "convex/schema.cms.ts"];
+      for (const file of cmsFiles) {
+        const targetFilePath = path7.join(targetPath, file);
+        const sourceFilePath = `packages/backend/${file}`;
+        if (await fs7.pathExists(targetFilePath)) {
+          await createBackup(targetFilePath);
+        }
+        try {
+          await fs7.remove(targetFilePath);
+          await downloadAndExtractPackage(sourceFilePath, targetFilePath);
+        } catch {
+        }
+      }
+    }
+    const newConfig = {
+      ...config,
+      version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    manifest.packages[pkg] = newConfig;
+    spinner.succeed(`Upgraded ${PACKAGE_NAMES[pkg]} to ${version}`);
+  } catch (error) {
+    spinner.fail(`Failed to upgrade ${PACKAGE_NAMES[pkg]}`);
+    throw error;
+  }
+}
+function getSourcePath2(pkg) {
+  switch (pkg) {
+    case "cms":
+      return "apps/cms";
+    case "backend":
+      return "packages/backend";
+    case "shared":
+      return "packages/cms-shared";
+    case "types":
+      return "packages/type-generator";
+    default:
+      throw new Error(`Unknown package: ${pkg}`);
+  }
+}
+
 // src/utils/package-info.ts
-import fs8 from "fs-extra";
 import path8 from "path";
 import { fileURLToPath } from "url";
+import fs8 from "fs-extra";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path8.dirname(__filename);
 async function getPackageInfo() {