shipd 0.1.0

package/dist/index.js

@@ -0,0 +1,1366 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command3 } from "commander";
+import inquirer3 from "inquirer";
+
+// src/prompts/index.ts
+import inquirer from "inquirer";
+
+// src/utils/validators.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    return "Project name is required";
+  }
+  const invalidChars = /[<>:"|?*\x00-\x1F]/;
+  if (invalidChars.test(name)) {
+    return "Project name contains invalid characters";
+  }
+  if (name.startsWith(".") || name.startsWith(" ") || name.endsWith(" ")) {
+    return "Project name cannot start with a dot or space, or end with a space";
+  }
+  const targetPath = resolve(process.cwd(), name);
+  if (existsSync(targetPath)) {
+    return `Directory "${name}" already exists`;
+  }
+  return true;
+}
+
+// src/prompts/index.ts
+async function runPrompts(projectName) {
+  if (projectName) {
+    console.log(`
+\u{1F4C1} Project name: ${projectName}`);
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      default: projectName,
+      when: !projectName,
+      validate: validateProjectName
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Project description:",
+      default: "A modern SaaS application"
+    },
+    {
+      type: "checkbox",
+      name: "features",
+      message: "Select optional features to include:",
+      choices: [
+        { name: "Polar.sh Payments & Subscriptions", value: "payments", checked: true },
+        { name: "OpenAI Chat Integration", value: "ai-chat", checked: true },
+        { name: "Cloudflare R2 File Uploads", value: "file-upload", checked: true },
+        { name: "PostHog Analytics", value: "analytics", checked: true }
+      ]
+    },
+    {
+      type: "list",
+      name: "packageManager",
+      message: "Package manager:",
+      choices: ["npm", "pnpm", "yarn"],
+      default: "npm"
+    }
+  ]);
+  return {
+    projectName: projectName || answers.projectName,
+    description: answers.description,
+    features: ["auth", "database", ...answers.features],
+    // Always include auth & database
+    packageManager: answers.packageManager
+  };
+}
+
+// src/generators/project.ts
+import { resolve as resolve3 } from "path";
+import ora from "ora";
+import { execa } from "execa";
+import fs from "fs-extra";
+
+// src/utils/template-config.ts
+import { readFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join, resolve as resolve2, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename);
+function getTemplatePath() {
+  const distPath = resolve2(__dirname2, "../../template");
+  if (existsSync2(distPath)) {
+    return distPath;
+  }
+  const srcPath = resolve2(__dirname2, "../../../template");
+  if (existsSync2(srcPath)) {
+    return srcPath;
+  }
+  const absolutePath = resolve2(__dirname2, "../../../../packages/template");
+  if (existsSync2(absolutePath)) {
+    return absolutePath;
+  }
+  throw new Error(`Template directory not found. Tried paths:
+    - ${distPath}
+    - ${srcPath}
+    - ${absolutePath}`);
+}
+async function loadTemplateConfig() {
+  const templatePath = getTemplatePath();
+  const configPath = join(templatePath, "template.config.json");
+  if (!existsSync2(configPath)) {
+    throw new Error(`template.config.json not found at ${configPath}`);
+  }
+  const content = await readFile(configPath, "utf-8");
+  return JSON.parse(content);
+}
+
+// src/utils/file-system.ts
+import { existsSync as existsSync3 } from "fs";
+import { cp, rm, readdir, readFile as readFile2, writeFile } from "fs/promises";
+import { join as join2, relative } from "path";
+import { globby } from "globby";
+var DEFAULT_EXCLUDES = [
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/coverage/**",
+  "**/.env",
+  "**/.env.local",
+  "**/template.config.json"
+];
+async function copyTemplate(sourcePath, targetPath, excludePatterns = []) {
+  const allExcludes = [...DEFAULT_EXCLUDES, ...excludePatterns];
+  await cp(sourcePath, targetPath, {
+    recursive: true,
+    filter: (src, _dest) => {
+      const relativePath = relative(sourcePath, src);
+      return !shouldExclude(relativePath, allExcludes);
+    }
+  });
+}
+function shouldExclude(filePath, patterns) {
+  return patterns.some((pattern) => {
+    const regex = new RegExp(
+      pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\./g, "\\.")
+    );
+    return regex.test(filePath);
+  });
+}
+async function removeFeatureFiles(targetPath, featureFiles) {
+  for (const filePattern of featureFiles) {
+    const files = await globby(filePattern, {
+      cwd: targetPath,
+      absolute: true,
+      dot: true
+    });
+    for (const file of files) {
+      await rm(file, { recursive: true, force: true });
+    }
+  }
+}
+async function removeEmptyDirectories(dirPath) {
+  if (!existsSync3(dirPath)) {
+    return;
+  }
+  const entries = await readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const fullPath = join2(dirPath, entry.name);
+      await removeEmptyDirectories(fullPath);
+    }
+  }
+  const remaining = await readdir(dirPath);
+  if (remaining.length === 0) {
+    await rm(dirPath, { recursive: true, force: true });
+  }
+}
+async function removeConditionalBlocks(targetPath, unselectedFeatures) {
+  const featureMarkers = {
+    "ai-chat": "AI_CHAT",
+    "payments": "PAYMENTS",
+    "file-upload": "FILE_UPLOAD",
+    "analytics": "ANALYTICS"
+  };
+  const filesToCheck = await globby("**/*.{ts,tsx,js,jsx}", {
+    cwd: targetPath,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/.next/**"]
+  });
+  for (const filePath of filesToCheck) {
+    let content = await readFile2(filePath, "utf-8");
+    let modified = false;
+    for (const feature of unselectedFeatures) {
+      const marker = featureMarkers[feature];
+      if (!marker) continue;
+      const blockRegex = new RegExp(
+        `\\/\\*${marker}_START\\*\\/[\\s\\S]*?\\/\\*${marker}_END\\*\\/\\n?`,
+        "g"
+      );
+      const jsxBlockRegex = new RegExp(
+        `\\{\\s*\\/\\*${marker}_START\\*\\/\\s*\\}[\\s\\S]*?\\{\\s*\\/\\*${marker}_END\\*\\/\\s*\\}\\n?`,
+        "g"
+      );
+      if (blockRegex.test(content) || jsxBlockRegex.test(content)) {
+        content = content.replace(blockRegex, "");
+        content = content.replace(jsxBlockRegex, "");
+        modified = true;
+      }
+    }
+    if (modified) {
+      await writeFile(filePath, content, "utf-8");
+    }
+  }
+}
+async function removeUnselectedFeatures(targetPath, selectedFeatures, templateConfig) {
+  const allFeatures = Object.keys(templateConfig.features);
+  const unselectedFeatures = allFeatures.filter(
+    (f) => !selectedFeatures.includes(f) && templateConfig.features[f].optional
+  );
+  await removeConditionalBlocks(targetPath, unselectedFeatures);
+  for (const feature of unselectedFeatures) {
+    const featureConfig = templateConfig.features[feature];
+    if (featureConfig.files.length > 0) {
+      await removeFeatureFiles(targetPath, featureConfig.files);
+    }
+  }
+  await removeEmptyDirectories(targetPath);
+}
+
+// src/transformers/template-vars.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
+function toKebabCase(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function toPascalCase(str) {
+  return str.replace(/[^a-z0-9]+/gi, " ").split(" ").filter((word) => word.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function generateVariables(config) {
+  return {
+    PROJECT_NAME: config.projectName,
+    PROJECT_NAME_KEBAB: toKebabCase(config.projectName),
+    PROJECT_NAME_PASCAL: toPascalCase(config.projectName),
+    PROJECT_DESCRIPTION: config.description,
+    APP_URL: "http://localhost:3000"
+  };
+}
+async function replaceInFile(filePath, variables) {
+  if (!existsSync4(filePath)) {
+    return;
+  }
+  let content = await readFile3(filePath, "utf-8");
+  Object.entries(variables).forEach(([key, value]) => {
+    const regex = new RegExp(`{{${key}}}`, "g");
+    content = content.replace(regex, value);
+  });
+  await writeFile2(filePath, content, "utf-8");
+}
+async function replaceTemplateVariables(targetPath, config) {
+  const variables = generateVariables(config);
+  const filesToProcess = [
+    "package.json",
+    "README.md",
+    "app/layout.tsx",
+    "app/sign-in/page.tsx",
+    "app/sign-up/page.tsx",
+    ".env.example"
+  ];
+  for (const file of filesToProcess) {
+    const filePath = join3(targetPath, file);
+    await replaceInFile(filePath, variables);
+  }
+}
+
+// src/generators/package-json.ts
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
+async function generatePackageJson(targetPath, selectedFeatures, templateConfig) {
+  const packageJsonPath = join4(targetPath, "package.json");
+  const packageJson = JSON.parse(await readFile4(packageJsonPath, "utf-8"));
+  const templatePackageJsonPath = join4(getTemplatePath(), "package.json");
+  const templatePackageJson = JSON.parse(await readFile4(templatePackageJsonPath, "utf-8"));
+  const dependencies = {};
+  const devDependencies = {};
+  const coreDeps = [
+    "next",
+    "react",
+    "react-dom",
+    "typescript",
+    "tailwindcss",
+    "dotenv",
+    "@radix-ui/react-avatar",
+    "@radix-ui/react-slot",
+    "@radix-ui/react-dialog",
+    "@radix-ui/react-dropdown-menu",
+    "@radix-ui/react-label",
+    "@radix-ui/react-tabs",
+    "@radix-ui/react-separator",
+    "@radix-ui/react-checkbox",
+    "@radix-ui/react-switch",
+    "class-variance-authority",
+    "clsx",
+    "tailwind-merge",
+    "lucide-react",
+    "next-themes",
+    "sonner",
+    "tailwindcss-animate",
+    "framer-motion",
+    "motion",
+    "@vercel/analytics",
+    "zod",
+    "react-hook-form",
+    "@hookform/resolvers",
+    "drizzle-orm",
+    "postgres",
+    "better-auth",
+    "@polar-sh/better-auth",
+    "@polar-sh/sdk",
+    "@neondatabase/serverless",
+    "resend",
+    "@react-email/components",
+    "@react-email/render"
+  ];
+  const coreDevDeps = [
+    "@types/node",
+    "@types/react",
+    "@types/react-dom",
+    "eslint",
+    "eslint-config-next",
+    "@eslint/eslintrc",
+    "drizzle-kit",
+    "@tailwindcss/postcss",
+    "tw-animate-css"
+  ];
+  coreDeps.forEach((dep) => {
+    if (templatePackageJson.dependencies?.[dep]) {
+      dependencies[dep] = templatePackageJson.dependencies[dep];
+    }
+  });
+  coreDevDeps.forEach((dep) => {
+    if (templatePackageJson.devDependencies?.[dep]) {
+      devDependencies[dep] = templatePackageJson.devDependencies[dep];
+    }
+  });
+  for (const feature of selectedFeatures) {
+    const featureConfig = templateConfig.features[feature];
+    if (featureConfig) {
+      for (const dep of featureConfig.dependencies || []) {
+        if (templatePackageJson.dependencies?.[dep]) {
+          dependencies[dep] = templatePackageJson.dependencies[dep];
+        }
+      }
+      for (const dep of featureConfig.devDependencies || []) {
+        if (templatePackageJson.devDependencies?.[dep]) {
+          devDependencies[dep] = templatePackageJson.devDependencies[dep];
+        }
+      }
+    }
+  }
+  const sortedDeps = Object.keys(dependencies).sort().reduce((acc, key) => {
+    acc[key] = dependencies[key];
+    return acc;
+  }, {});
+  const sortedDevDeps = Object.keys(devDependencies).sort().reduce((acc, key) => {
+    acc[key] = devDependencies[key];
+    return acc;
+  }, {});
+  packageJson.dependencies = sortedDeps;
+  packageJson.devDependencies = sortedDevDeps;
+  await writeFile3(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+}
+
+// src/generators/env.ts
+import { writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
+var ENV_DEFAULTS = {
+  // Database
+  "DATABASE_URL": "postgresql://user:password@localhost:5432/mydb",
+  // Auth
+  "BETTER_AUTH_SECRET": "please-change-this-to-a-random-32-character-string-or-longer",
+  "GOOGLE_CLIENT_ID": "your-google-client-id.apps.googleusercontent.com",
+  "GOOGLE_CLIENT_SECRET": "your-google-client-secret",
+  // Polar.sh Payments
+  "POLAR_ACCESS_TOKEN": "your-polar-access-token",
+  "POLAR_SUCCESS_URL": "http://localhost:3000/success",
+  "POLAR_WEBHOOK_SECRET": "your-polar-webhook-secret",
+  "NEXT_PUBLIC_STARTER_TIER": "your-starter-tier-id",
+  "NEXT_PUBLIC_STARTER_SLUG": "your-organization-slug",
+  // OpenAI
+  "OPENAI_API_KEY": "sk-your-openai-api-key",
+  // Cloudflare R2
+  "R2_UPLOAD_IMAGE_ACCESS_KEY_ID": "your-r2-access-key-id",
+  "R2_UPLOAD_IMAGE_SECRET_ACCESS_KEY": "your-r2-secret-access-key",
+  "CLOUDFLARE_ACCOUNT_ID": "your-cloudflare-account-id",
+  "R2_UPLOAD_IMAGE_BUCKET_NAME": "your-bucket-name",
+  // PostHog
+  "NEXT_PUBLIC_POSTHOG_KEY": "phc_your-posthog-project-key",
+  "NEXT_PUBLIC_POSTHOG_HOST": "https://app.posthog.com"
+};
+async function generateEnvExample(targetPath, selectedFeatures, templateConfig) {
+  const lines = [];
+  lines.push("# Environment Variables");
+  lines.push("# Copy this file to .env.local and customize the values");
+  lines.push("");
+  lines.push("# \u26A0\uFE0F  REQUIRED FOR BASIC FUNCTIONALITY:");
+  lines.push("#    - DATABASE_URL (for data storage)");
+  lines.push("#    - BETTER_AUTH_SECRET (for authentication)");
+  lines.push("#    - GOOGLE_CLIENT_ID & GOOGLE_CLIENT_SECRET (for Google login)");
+  lines.push("");
+  lines.push("# \u2139\uFE0F  OPTIONAL SERVICES:");
+  lines.push("#    - POLAR_* variables (only needed for subscription payments)");
+  lines.push("#    - OPENAI_API_KEY (only needed for AI chat features)");
+  lines.push("#    - R2_* variables (only needed for file uploads)");
+  lines.push("#    - POSTHOG_* variables (only needed for analytics)");
+  lines.push("");
+  lines.push("# The app will launch with these placeholder values, but configure real services for production");
+  lines.push("");
+  lines.push("# Application");
+  lines.push("NEXT_PUBLIC_APP_URL=http://localhost:3000");
+  lines.push("");
+  for (const feature of selectedFeatures) {
+    const featureConfig = templateConfig.features[feature];
+    if (featureConfig && featureConfig.envVars.length > 0) {
+      const featureName = feature.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+      const isOptional = !featureConfig.required;
+      const requirementNote = isOptional ? " (Optional - only needed if using this feature)" : " (Required)";
+      lines.push(`# ${featureName}${requirementNote}`);
+      featureConfig.envVars.forEach((envVar) => {
+        const defaultValue = ENV_DEFAULTS[envVar] || "";
+        lines.push(`${envVar}=${defaultValue}`);
+      });
+      lines.push("");
+    }
+  }
+  await writeFile4(
+    join5(targetPath, ".env.example"),
+    lines.join("\n")
+  );
+}
+
+// src/generators/readme.ts
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { join as join6 } from "path";
+async function generateReadme(targetPath, config, templateConfig) {
+  const readmePath = join6(targetPath, "README.md");
+  let readme = await readFile5(readmePath, "utf-8");
+  const featureSections = [];
+  if (config.features.includes("payments")) {
+    featureSections.push(`
+### Polar.sh Setup (Payments)
+1. Create account at [polar.sh](https://polar.sh)
+2. Create organization and products/subscription tiers
+3. Get your access token from Settings \u2192 API
+4. Add to \`.env.local\`:
+   - \`POLAR_ACCESS_TOKEN\`
+   - \`POLAR_WEBHOOK_SECRET\`
+   - \`NEXT_PUBLIC_STARTER_TIER\`
+   - \`NEXT_PUBLIC_STARTER_SLUG\`
+`);
+  }
+  if (config.features.includes("ai-chat")) {
+    featureSections.push(`
+### OpenAI Setup (AI Chat)
+1. Get API key from [platform.openai.com](https://platform.openai.com)
+2. Add to \`.env.local\`:
+   - \`OPENAI_API_KEY\`
+`);
+  }
+  if (config.features.includes("file-upload")) {
+    featureSections.push(`
+### Cloudflare R2 Setup (File Uploads)
+1. Create R2 bucket in Cloudflare dashboard
+2. Generate API tokens with R2 permissions
+3. Add to \`.env.local\`:
+   - \`R2_UPLOAD_IMAGE_ACCESS_KEY_ID\`
+   - \`R2_UPLOAD_IMAGE_SECRET_ACCESS_KEY\`
+   - \`CLOUDFLARE_ACCOUNT_ID\`
+   - \`R2_UPLOAD_IMAGE_BUCKET_NAME\`
+`);
+  }
+  if (config.features.includes("analytics")) {
+    featureSections.push(`
+### PostHog Setup (Analytics)
+1. Create account at [posthog.com](https://posthog.com)
+2. Create a new project
+3. Add to \`.env.local\`:
+   - \`NEXT_PUBLIC_POSTHOG_KEY\`
+   - \`NEXT_PUBLIC_POSTHOG_HOST=https://app.posthog.com\`
+`);
+  }
+  if (featureSections.length > 0) {
+    const setupSection = `
+
+## \u{1F527} Service Configuration
+${featureSections.join("\n")}`;
+    readme += setupSection;
+  }
+  readme += `
+
+---
+
+**Generated with** [Shipd](https://github.com/yourusername/shipd)
+`;
+  await writeFile5(readmePath, readme);
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var SHIPD_ASCII = chalk.hex("#ff7043")(`                                                    # #  ( )
+                                                 ___#_#___|__
+                                             _  |____________|  _
+                                      _=====| | |            | | |==== _
+                                =====| |.---------------------------. | |====
+   <---------------------------'                                        '----------------/
+     \\    .d8888. db   db d888888b d8888b. d8888b.                                     /
+      \\   88'  YP 88   88   \\\`88'   88  \\\`8D 88  \\\`8D                                    /
+       \\  \\\`8bo.   88ooo88    88    88oodD' 88   88                                   /
+        \\   \\\`Y8b. 88~~~88    88    88~~~   88   88                                  /
+         \\ db   8D 88   88   .88.   88      88  .8D                                 /
+          \\\`8888Y' YP   YP Y888888P 88      Y8888D'                                /
+           \\_____________________________________________________________________ /
+  wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
+wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
+   wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
+`);
+var logger = {
+  intro: (message) => {
+    console.log("\n" + chalk.bold.cyan(message) + "\n");
+  },
+  success: (message) => {
+    console.log(chalk.green("\u2713") + " " + message);
+  },
+  error: (message) => {
+    console.log(chalk.red("\u2717") + " " + message);
+  },
+  info: (message) => {
+    console.log(chalk.blue("\u2139") + " " + message);
+  },
+  step: (message) => {
+    console.log(chalk.cyan("\u2192") + " " + message);
+  },
+  warn: (message) => {
+    console.log(chalk.yellow("\u26A0") + " " + message);
+  }
+};
+
+// src/generators/project.ts
+async function generateProject(config) {
+  const targetPath = resolve3(process.cwd(), config.projectName);
+  if (await fs.pathExists(targetPath)) {
+    const files = await fs.readdir(targetPath);
+    if (files.length > 0) {
+      const hasPkgJson = await fs.pathExists(resolve3(targetPath, "package.json"));
+      const hasGit = await fs.pathExists(resolve3(targetPath, ".git"));
+      const hasNodeModules = await fs.pathExists(resolve3(targetPath, "node_modules"));
+      if (hasPkgJson || hasGit || hasNodeModules) {
+        throw new Error(
+          `Directory "${config.projectName}" appears to contain an existing project.
+  - package.json: ${hasPkgJson ? "\u2713 found" : "\u2717 not found"}
+  - .git: ${hasGit ? "\u2713 found" : "\u2717 not found"}
+  - node_modules: ${hasNodeModules ? "\u2713 found" : "\u2717 not found"}
+
+To avoid data loss, shipd init will not overwrite existing projects.
+Please:
+  1. Choose a different project name, or
+  2. Delete the existing directory first, or
+  3. Use 'shipd append' to add features to the existing project`
+        );
+      }
+      logger.warn(`Directory "${config.projectName}" is not empty but doesn't appear to be a project.`);
+      logger.warn("Existing files may be overwritten. Press Ctrl+C to cancel or wait 3 seconds to continue...");
+      await new Promise((resolve5) => setTimeout(resolve5, 3e3));
+    }
+  }
+  const templateConfig = await loadTemplateConfig();
+  const templatePath = getTemplatePath();
+  const copySpinner = ora("Copying template files...").start();
+  try {
+    await copyTemplate(templatePath, targetPath);
+    copySpinner.succeed("Template files copied");
+  } catch (error) {
+    copySpinner.fail("Failed to copy template files");
+    throw error;
+  }
+  const removeSpinner = ora("Removing unselected features...").start();
+  try {
+    await removeUnselectedFeatures(targetPath, config.features, templateConfig);
+    removeSpinner.succeed("Features filtered");
+  } catch (error) {
+    removeSpinner.fail("Failed to remove feature files");
+    throw error;
+  }
+  const varsSpinner = ora("Replacing template variables...").start();
+  try {
+    await replaceTemplateVariables(targetPath, config);
+    varsSpinner.succeed("Variables replaced");
+  } catch (error) {
+    varsSpinner.fail("Failed to replace variables");
+    throw error;
+  }
+  const pkgSpinner = ora("Generating package.json...").start();
+  try {
+    await generatePackageJson(targetPath, config.features, templateConfig);
+    pkgSpinner.succeed("package.json generated");
+  } catch (error) {
+    pkgSpinner.fail("Failed to generate package.json");
+    throw error;
+  }
+  const envSpinner = ora("Generating .env.example...").start();
+  try {
+    await generateEnvExample(targetPath, config.features, templateConfig);
+    envSpinner.succeed(".env.example generated");
+  } catch (error) {
+    envSpinner.fail("Failed to generate .env.example");
+    throw error;
+  }
+  const readmeSpinner = ora("Updating README...").start();
+  try {
+    await generateReadme(targetPath, config, templateConfig);
+    readmeSpinner.succeed("README updated");
+  } catch (error) {
+    readmeSpinner.fail("Failed to update README");
+    throw error;
+  }
+  const gitSpinner = ora("Initializing git repository...").start();
+  try {
+    await execa("git", ["init"], { cwd: targetPath });
+    await execa("git", ["add", "."], { cwd: targetPath });
+    await execa("git", ["commit", "-m", "Initial commit from Shipd"], { cwd: targetPath });
+    gitSpinner.succeed("Git repository initialized");
+  } catch (error) {
+    gitSpinner.fail("Failed to initialize git");
+    throw error;
+  }
+  let installInterval;
+  const installSpinner = ora("Preparing to install dependencies...").start();
+  try {
+    const pkgJson = await fs.readJson(resolve3(targetPath, "package.json"));
+    const deps = Object.keys(pkgJson.dependencies || {}).length;
+    const devDeps = Object.keys(pkgJson.devDependencies || {}).length;
+    const totalDeps = deps + devDeps;
+    installSpinner.text = `Installing ${totalDeps} dependencies with ${config.packageManager}...
+  This may take 2-5 minutes depending on your connection`;
+    const startTime = Date.now();
+    installInterval = setInterval(() => {
+      const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+      installSpinner.text = `Installing ${totalDeps} dependencies (${elapsed}s elapsed)...
+  ${config.packageManager} install is running in background`;
+    }, 2e3);
+    await execa(config.packageManager, ["install"], {
+      cwd: targetPath,
+      stdio: "pipe"
+    });
+    clearInterval(installInterval);
+    const totalTime = Math.floor((Date.now() - startTime) / 1e3);
+    installSpinner.succeed(`Dependencies installed (${totalDeps} packages in ${totalTime}s)`);
+  } catch (error) {
+    if (installInterval) {
+      clearInterval(installInterval);
+    }
+    installSpinner.fail("Failed to install dependencies");
+    throw error;
+  }
+  logger.success(`
+Project "${config.projectName}" created successfully at:
+${targetPath}
+`);
+  console.log("\nNext steps:");
+  logger.step(`cd "${targetPath}"`);
+  logger.step("Copy .env.example to .env.local and configure your services");
+  logger.step(`${config.packageManager} run dev`);
+  logger.info('Tip: If you see "Could not read package.json", you are not in the project directory yet.');
+  if (config.features.includes("payments")) {
+    console.log("\n\u{1F4B3} Polar.sh Setup Required:");
+    logger.info("Visit https://polar.sh to create your account and configure payment tiers");
+  }
+  if (config.features.includes("ai-chat")) {
+    console.log("\n\u{1F916} OpenAI Setup Required:");
+    logger.info("Get your API key from https://platform.openai.com");
+  }
+  if (config.features.includes("file-upload")) {
+    console.log("\n\u{1F4C1} Cloudflare R2 Setup Required:");
+    logger.info("Create an R2 bucket in your Cloudflare dashboard");
+  }
+  if (config.features.includes("analytics")) {
+    console.log("\n\u{1F4CA} PostHog Setup Required:");
+    logger.info("Create a project at https://posthog.com");
+  }
+  console.log("\n");
+}
+
+// src/auth/token-storage.ts
+import fs3 from "fs-extra";
+
+// src/config/paths.ts
+import os from "os";
+import path from "path";
+import fs2 from "fs-extra";
+function getConfigDir() {
+  const homeDir = os.homedir();
+  const configDir = path.join(homeDir, ".shipd");
+  fs2.ensureDirSync(configDir);
+  return configDir;
+}
+function getAuthPath() {
+  return path.join(getConfigDir(), "auth.json");
+}
+
+// src/auth/token-storage.ts
+function loadAuth() {
+  const authPath = getAuthPath();
+  try {
+    if (!fs3.existsSync(authPath)) {
+      return null;
+    }
+    const data = fs3.readJsonSync(authPath);
+    return data;
+  } catch (error) {
+    console.error("Failed to load auth data:", error);
+    return null;
+  }
+}
+function saveAuth(authData) {
+  const authPath = getAuthPath();
+  try {
+    fs3.writeJsonSync(authPath, authData, { spaces: 2 });
+  } catch (error) {
+    console.error("Failed to save auth data:", error);
+    throw new Error("Failed to save authentication data");
+  }
+}
+function clearAuth() {
+  const authPath = getAuthPath();
+  try {
+    if (fs3.existsSync(authPath)) {
+      fs3.removeSync(authPath);
+    }
+  } catch (error) {
+    console.error("Failed to clear auth data:", error);
+    throw new Error("Failed to clear authentication data");
+  }
+}
+function isAuthenticated() {
+  const auth = loadAuth();
+  if (!auth) {
+    return false;
+  }
+  const expiresAt = new Date(auth.expiresAt);
+  const now = /* @__PURE__ */ new Date();
+  if (now >= expiresAt) {
+    clearAuth();
+    return false;
+  }
+  return true;
+}
+
+// src/auth/token-validator.ts
+var API_BASE_URL = process.env.SAAS_SCAFFOLD_API_URL || "https://www.shipd.dev";
+async function validateToken(token) {
+  const authToken = token || loadAuth()?.token;
+  if (!authToken) {
+    return { valid: false, error: "No authentication token found" };
+  }
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/cli/validate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ token: authToken })
+    });
+    if (!response.ok) {
+      clearAuth();
+      return { valid: false, error: "Invalid or expired token" };
+    }
+    const data = await response.json();
+    if (data.subscriptionStatus && data.subscriptionStatus !== "active") {
+      clearAuth();
+      return {
+        valid: false,
+        error: `Subscription ${data.subscriptionStatus}. Please renew at ${API_BASE_URL}/pricing`
+      };
+    }
+    return data;
+  } catch (error) {
+    console.error("Token validation failed:", error);
+    return {
+      valid: false,
+      error: "Unable to validate token. Please check your internet connection."
+    };
+  }
+}
+function isDevelopmentMode() {
+  return process.env.SAAS_SCAFFOLD_DEV === "true";
+}
+async function ensureAuthenticated(mockMode = false) {
+  if (mockMode || isDevelopmentMode()) {
+    console.log("\x1B[33m\u26A0\x1B[0m  Running in mock mode (authentication bypassed)");
+    return;
+  }
+  const auth = loadAuth();
+  if (!auth) {
+    console.error("\n\u274C Not authenticated.");
+    console.error("\nPlease run: \x1B[36mshipd login\x1B[0m\n");
+    console.error("\x1B[2mTip: Use --mock flag to skip authentication during development\x1B[0m\n");
+    process.exit(1);
+  }
+  const expiresAt = new Date(auth.expiresAt);
+  const now = /* @__PURE__ */ new Date();
+  if (now >= expiresAt) {
+    clearAuth();
+    console.error("\n\u274C Session expired.");
+    console.error("\nPlease run: \x1B[36mshipd login\x1B[0m\n");
+    process.exit(1);
+  }
+  const validation = await validateToken(auth.token);
+  if (!validation.valid) {
+    console.error(`
+\u274C Authentication failed: ${validation.error}`);
+    console.error("\nPlease run: \x1B[36mshipd login\x1B[0m\n");
+    process.exit(1);
+  }
+  console.log("\x1B[32m\u2713\x1B[0m Authenticated");
+}
+
+// src/commands/init.ts
+async function initCommand(projectName, options) {
+  try {
+    await ensureAuthenticated(options?.mock || false);
+    console.log(SHIPD_ASCII);
+    logger.intro("Welcome aboard! Let's get shipping");
+    const config = await runPrompts(projectName);
+    await generateProject(config);
+  } catch (error) {
+    logger.error("Project generation failed");
+    if (error instanceof Error) {
+      console.error("\n" + error.message);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+import chalk2 from "chalk";
+async function listCommand() {
+  logger.intro("Available Features");
+  console.log("\n" + chalk2.bold("Core (Always Included):"));
+  console.log("  \u2022 Next.js 15 with App Router");
+  console.log("  \u2022 Better Auth + Google OAuth");
+  console.log("  \u2022 Neon PostgreSQL + Drizzle ORM");
+  console.log("  \u2022 shadcn/ui components (24 components)");
+  console.log("  \u2022 Dark/Light mode");
+  console.log("  \u2022 User dashboard");
+  console.log("\n" + chalk2.bold("Optional Features:"));
+  console.log("  \u2022 Polar.sh payments & subscriptions");
+  console.log("  \u2022 OpenAI chat integration");
+  console.log("  \u2022 Cloudflare R2 file uploads");
+  console.log("  \u2022 PostHog analytics");
+  console.log("\n" + chalk2.bold("Usage:"));
+  console.log("  npx shipd init <project-name>");
+  console.log("");
+}
+
+// src/commands/login.ts
+import { Command } from "commander";
+
+// src/auth/auth-manager.ts
+import { nanoid } from "nanoid";
+import open from "open";
+import ora2 from "ora";
+var API_BASE_URL2 = process.env.SAAS_SCAFFOLD_API_URL || "https://www.shipd.dev";
+var POLL_INTERVAL = 2e3;
+var MAX_POLL_TIME = 3e5;
+function generateDeviceCode() {
+  return nanoid(10).toUpperCase().match(/.{1,4}/g)?.join("-") || nanoid(10);
+}
+async function openAuthPage(deviceCode) {
+  const authUrl = `${API_BASE_URL2}/cli/auth?code=${deviceCode}`;
+  console.log("\n\x1B[36m\u2192\x1B[0m Opening browser for authentication...");
+  console.log(`\x1B[2m  ${authUrl}\x1B[0m
+`);
+  try {
+    await open(authUrl);
+  } catch (error) {
+    console.log("\n\x1B[33m\u26A0\x1B[0m  Could not open browser automatically.");
+    console.log("Please open this URL manually:\n");
+    console.log(`\x1B[36m${authUrl}\x1B[0m
+`);
+  }
+}
+async function pollForAuth(deviceCode) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < MAX_POLL_TIME) {
+    try {
+      const response = await fetch(`${API_BASE_URL2}/api/cli/poll?code=${deviceCode}`, {
+        method: "GET"
+      });
+      if (!response.ok) {
+        if (response.status === 410) {
+          throw new Error("Authentication code expired. Please try again.");
+        }
+        if (response.status === 404) {
+          throw new Error("Invalid authentication code.");
+        }
+        await sleep(POLL_INTERVAL);
+        continue;
+      }
+      const data = await response.json();
+      if (data.status === "success" && data.token) {
+        return {
+          token: data.token,
+          userId: data.userId,
+          email: data.email,
+          expiresAt: data.expiresAt,
+          subscriptionStatus: data.subscriptionStatus || "active"
+        };
+      }
+      if (data.status === "expired") {
+        throw new Error("Authentication session expired. Please try again.");
+      }
+      await sleep(POLL_INTERVAL);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("expired")) {
+        throw error;
+      }
+      await sleep(POLL_INTERVAL);
+    }
+  }
+  throw new Error("Authentication timeout. Please try again.");
+}
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function login() {
+  console.log("\n\x1B[1m\u{1F680} Welcome to shipd!\x1B[0m\n");
+  const deviceCode = generateDeviceCode();
+  console.log(`\x1B[2mDevice code: ${deviceCode}\x1B[0m`);
+  await openAuthPage(deviceCode);
+  const spinner = ora2({
+    text: "Waiting for authentication...",
+    color: "cyan"
+  }).start();
+  try {
+    const authData = await pollForAuth(deviceCode);
+    spinner.succeed("Authentication successful!");
+    saveAuth(authData);
+    console.log("\n\x1B[32m\u2713\x1B[0m Logged in as \x1B[1m" + authData.email + "\x1B[0m");
+    console.log("\x1B[32m\u2713\x1B[0m Subscription status: \x1B[1m" + authData.subscriptionStatus + "\x1B[0m\n");
+    console.log("You can now use shipd CLI commands.\n");
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    if (error instanceof Error) {
+      console.error("\n\x1B[31m\u2717\x1B[0m " + error.message + "\n");
+    } else {
+      console.error("\n\x1B[31m\u2717\x1B[0m Unknown error occurred\n");
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/login.ts
+function createLoginCommand() {
+  const command = new Command("login");
+  command.description("Authenticate with shipd").action(async () => {
+    if (isAuthenticated()) {
+      const auth = loadAuth();
+      console.log("\n\x1B[32m\u2713\x1B[0m Already logged in as \x1B[1m" + auth?.email + "\x1B[0m");
+      console.log("\nTo logout, run: \x1B[36mshipd logout\x1B[0m\n");
+      return;
+    }
+    await login();
+  });
+  return command;
+}
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+function createLogoutCommand() {
+  const command = new Command2("logout");
+  command.description("Logout from shipd").action(async () => {
+    if (!isAuthenticated()) {
+      console.log("\n\x1B[33m\u26A0\x1B[0m  Not currently logged in.\n");
+      return;
+    }
+    const auth = loadAuth();
+    const email = auth?.email;
+    clearAuth();
+    console.log("\n\x1B[32m\u2713\x1B[0m Successfully logged out");
+    if (email) {
+      console.log(`\x1B[2m  (${email})\x1B[0m`);
+    }
+    console.log("\nTo login again, run: \x1B[36mshipd login\x1B[0m\n");
+  });
+  return command;
+}
+
+// src/commands/append.ts
+import inquirer2 from "inquirer";
+import { existsSync as existsSync5 } from "fs";
+import { join as join7, resolve as resolve4 } from "path";
+import ora3 from "ora";
+import fs4 from "fs-extra";
+async function detectProject(cwd) {
+  const pkgPath = join7(cwd, "package.json");
+  if (!existsSync5(pkgPath)) {
+    throw new Error("No package.json found. Make sure you're in a Next.js project directory.");
+  }
+  const pkg = await fs4.readJson(pkgPath);
+  const isNextJs = !!(pkg.dependencies?.next || pkg.devDependencies?.next);
+  if (!isNextJs) {
+    throw new Error("This doesn't appear to be a Next.js project. shipd append requires a Next.js project.");
+  }
+  const hasAppRouter = existsSync5(join7(cwd, "app"));
+  if (!hasAppRouter) {
+    throw new Error("App Router not detected. shipd append requires Next.js App Router (app directory).");
+  }
+  let packageManager = "npm";
+  if (existsSync5(join7(cwd, "pnpm-lock.yaml"))) {
+    packageManager = "pnpm";
+  } else if (existsSync5(join7(cwd, "yarn.lock"))) {
+    packageManager = "yarn";
+  }
+  const installedFeatures = [];
+  const shipdManifest = join7(cwd, ".shipd", "manifest.json");
+  if (existsSync5(shipdManifest)) {
+    const manifest = await fs4.readJson(shipdManifest);
+    installedFeatures.push(...Object.keys(manifest.features || {}));
+  }
+  return {
+    isNextJs,
+    hasAppRouter,
+    packageManager,
+    installedFeatures
+  };
+}
+async function appendDocsFeature(targetPath, dryRun = false) {
+  const docsSourcePath = resolve4(__dirname, "../../../docs-template");
+  if (!existsSync5(docsSourcePath)) {
+    throw new Error("Docs template not found. This might be a development environment issue.");
+  }
+  const spinner = ora3("Copying docs feature (pages + components)...").start();
+  try {
+    if (dryRun) {
+      spinner.info("DRY RUN: Would copy docs pages and components from template");
+      return;
+    }
+    const docsTargetPath = join7(targetPath, "app", "docs");
+    await fs4.ensureDir(docsTargetPath);
+    await fs4.copy(docsSourcePath, docsTargetPath, {
+      overwrite: false,
+      errorOnExist: false,
+      filter: (src) => {
+        if (src.includes("/components/")) {
+          return false;
+        }
+        const relativePath = src.replace(docsSourcePath, "");
+        const targetFile = join7(docsTargetPath, relativePath);
+        if (existsSync5(targetFile)) {
+          logger.warn(`Skipping existing file: ${relativePath}`);
+          return false;
+        }
+        return true;
+      }
+    });
+    const componentsSourcePath = join7(docsSourcePath, "components", "docs");
+    const componentsTargetPath = join7(targetPath, "components", "docs");
+    if (existsSync5(componentsSourcePath)) {
+      await fs4.ensureDir(componentsTargetPath);
+      await fs4.copy(componentsSourcePath, componentsTargetPath, {
+        overwrite: false,
+        errorOnExist: false,
+        filter: (src) => {
+          const relativePath = src.replace(componentsSourcePath, "");
+          const targetFile = join7(componentsTargetPath, relativePath);
+          if (existsSync5(targetFile)) {
+            logger.warn(`Skipping existing component: ${relativePath}`);
+            return false;
+          }
+          return true;
+        }
+      });
+    }
+    const uiComponentsSourcePath = join7(docsSourcePath, "components", "ui");
+    const uiComponentsTargetPath = join7(targetPath, "components", "ui");
+    if (existsSync5(uiComponentsSourcePath)) {
+      await fs4.ensureDir(uiComponentsTargetPath);
+      await fs4.copy(uiComponentsSourcePath, uiComponentsTargetPath, {
+        overwrite: false,
+        errorOnExist: false,
+        filter: (src) => {
+          const relativePath = src.replace(uiComponentsSourcePath, "");
+          const targetFile = join7(uiComponentsTargetPath, relativePath);
+          if (existsSync5(targetFile)) {
+            return false;
+          }
+          return true;
+        }
+      });
+    }
+    const utilsSourcePath = join7(docsSourcePath, "lib", "utils.ts");
+    const utilsTargetPath = join7(targetPath, "lib", "utils.ts");
+    if (existsSync5(utilsSourcePath) && !existsSync5(utilsTargetPath)) {
+      await fs4.ensureDir(join7(targetPath, "lib"));
+      await fs4.copy(utilsSourcePath, utilsTargetPath);
+    } else if (existsSync5(utilsTargetPath)) {
+    }
+    spinner.succeed("Docs feature copied (pages + components)");
+    const shipdDir = join7(targetPath, ".shipd");
+    await fs4.ensureDir(shipdDir);
+    const manifestPath = join7(shipdDir, "manifest.json");
+    let manifest = { version: "1.0.0", features: {} };
+    if (existsSync5(manifestPath)) {
+      manifest = await fs4.readJson(manifestPath);
+    }
+    manifest.features.docs = {
+      version: "1.0.0",
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      files: [
+        "app/docs/**/*",
+        "components/docs/**/*",
+        "components/ui/**/*",
+        "lib/utils.ts"
+      ]
+    };
+    await fs4.writeJson(manifestPath, manifest, { spaces: 2 });
+    const pkgPath = join7(targetPath, "package.json");
+    if (existsSync5(pkgPath)) {
+      const pkg = await fs4.readJson(pkgPath);
+      let updated = false;
+      const requiredDeps = {
+        "@radix-ui/react-slot": "^1.1.0",
+        "@radix-ui/react-dialog": "^1.1.0",
+        "class-variance-authority": "^0.7.0",
+        "clsx": "^2.1.1",
+        "tailwind-merge": "^2.5.4",
+        "lucide-react": "^0.469.0"
+      };
+      if (!pkg.dependencies) {
+        pkg.dependencies = {};
+      }
+      for (const [dep, version] of Object.entries(requiredDeps)) {
+        if (!pkg.dependencies[dep] && !pkg.devDependencies?.[dep]) {
+          pkg.dependencies[dep] = version;
+          updated = true;
+        }
+      }
+      if (updated) {
+        await fs4.writeJson(pkgPath, pkg, { spaces: 2 });
+        logger.info("Added missing dependencies to package.json");
+        logger.info("Run npm install (or your package manager) to install them");
+      }
+    }
+    const featureDocs = join7(shipdDir, "features");
+    await fs4.ensureDir(featureDocs);
+    const docsReadme = `# Docs Feature - Integration Guide
+
+**Installed:** ${(/* @__PURE__ */ new Date()).toISOString()}
+**Version:** 1.0.0
+
+## Overview
+
+This feature adds a complete, standalone documentation section to your Next.js application. All required components are included - no external dependencies needed.
+
+## Files Added
+
+### Pages
+- \`app/docs/page.tsx\` - Docs landing page
+- \`app/docs/layout.tsx\` - Docs layout with header and sidebar
+- \`app/docs/[slug]/page.tsx\` - Dynamic doc pages
+- \`app/docs/[slug]/[subslug]/page.tsx\` - Nested doc pages
+- \`app/docs/api/page.tsx\` - API documentation page
+- \`app/docs/documentation/page.tsx\` - Documentation page
+
+### Components (Standalone Package)
+All required components are included:
+- \`components/docs/docs-header.tsx\` - Docs header with navigation
+- \`components/docs/docs-sidebar.tsx\` - Sidebar navigation
+- \`components/docs/docs-toc.tsx\` - Table of contents component
+- \`components/docs/docs-category-page.tsx\` - Category page layout
+- \`components/docs/docs-code-card.tsx\` - Code snippet display
+- \`components/docs/docs-nav.ts\` - Navigation data structure
+
+## Dependencies
+
+This feature is **completely standalone** and includes:
+- \u2705 All required UI components (\`components/ui/*\`)
+- \u2705 Utility functions (\`lib/utils.ts\`)
+- \u2705 All docs-specific components (\`components/docs/*\`)
+
+**Smart Deduplication:** If UI components already exist in your project, they won't be overwritten.
+
+**Package Dependencies:** The following will be added to your \`package.json\` if missing:
+- \`@radix-ui/react-slot\` - For Button component
+- \`@radix-ui/react-dialog\` - For Sheet component
+- \`class-variance-authority\` - For component variants
+- \`clsx\` & \`tailwind-merge\` - For className utilities
+- \`lucide-react\` - For icons
+
+**Note:** Run \`npm install\` (or your package manager) after appending to install any new dependencies.
+
+## Setup Instructions
+
+1. **Access the docs**
+   - Visit \`/docs\` in your application
+   - The docs section is fully functional with navigation and layout
+
+2. **Customize content**
+   - Edit pages in \`app/docs/\` to customize content
+   - Update navigation in \`components/docs/docs-nav.ts\`
+   - Modify components in \`components/docs/\` to change styling/behavior
+
+3. **Add your own documentation**
+   - Create new pages in \`app/docs/\`
+   - Follow the existing page structure
+   - Add entries to \`docs-nav.ts\` to include in sidebar
+
+## Next Steps
+
+- Customize the docs landing page in \`app/docs/page.tsx\`
+- Update navigation structure in \`components/docs/docs-nav.ts\`
+- Add your own documentation pages
+- Customize styling in components if needed
+
+## Feature Status
+
+\u2705 **Standalone Package** - All components included
+\u2705 **No Missing Dependencies** - Everything needed is bundled
+\u2705 **Ready to Use** - Works immediately after append
+`;
+    await fs4.writeFile(join7(featureDocs, "docs.md"), docsReadme);
+  } catch (error) {
+    spinner.fail("Failed to copy docs pages");
+    throw error;
+  }
+}
+async function appendCommand(options) {
+  try {
+    const cwd = process.cwd();
+    logger.intro("Adding Shipd features to your project");
+    const detectSpinner = ora3("Detecting project...").start();
+    const projectInfo = await detectProject(cwd);
+    detectSpinner.succeed("Project validated");
+    logger.info(`\u2713 Next.js App Router project detected`);
+    logger.info(`\u2713 Package manager: ${projectInfo.packageManager}`);
+    if (projectInfo.installedFeatures.length > 0) {
+      logger.info(`\u2713 Installed features: ${projectInfo.installedFeatures.join(", ")}`);
+    }
+    const availableFeatures = ["docs"];
+    const alreadyInstalled = projectInfo.installedFeatures.filter((f) => availableFeatures.includes(f));
+    if (alreadyInstalled.includes("docs")) {
+      logger.warn("Docs feature is already installed!");
+      return;
+    }
+    let selectedFeatures;
+    if (options.features) {
+      selectedFeatures = options.features.split(",").map((f) => f.trim());
+    } else {
+      const answers = await inquirer2.prompt([
+        {
+          type: "checkbox",
+          name: "features",
+          message: "Select features to add:",
+          choices: [
+            { name: "Documentation Pages", value: "docs", checked: true }
+          ]
+        }
+      ]);
+      selectedFeatures = answers.features;
+    }
+    if (selectedFeatures.length === 0) {
+      logger.warn("No features selected. Exiting.");
+      return;
+    }
+    console.log("\n\u{1F4CB} Changes Preview:");
+    console.log("   Features to add:", selectedFeatures.join(", "));
+    console.log("   Mode:", options.dryRun ? "DRY RUN" : "LIVE");
+    if (!options.dryRun) {
+      const confirm = await inquirer2.prompt([
+        {
+          type: "confirm",
+          name: "proceed",
+          message: "Proceed with installation?",
+          default: true
+        }
+      ]);
+      if (!confirm.proceed) {
+        logger.warn("Installation cancelled");
+        return;
+      }
+    }
+    console.log();
+    for (const feature of selectedFeatures) {
+      if (feature === "docs") {
+        await appendDocsFeature(cwd, options.dryRun);
+      }
+    }
+    console.log();
+    logger.success("\u2728 Features added successfully!");
+    console.log();
+    console.log("\u{1F4D6} Next steps:");
+    console.log("   1. Visit /docs in your application");
+    console.log("   2. Customize the docs in app/docs/");
+    console.log("   3. Check .shipd/features/docs.md for details");
+    console.log();
+  } catch (error) {
+    logger.error("Failed to append features");
+    if (error instanceof Error) {
+      console.error("\n" + error.message);
+    }
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command3();
+program.name("shipd").description("Generate production-ready SaaS applications").version("0.1.0");
+program.addCommand(createLoginCommand());
+program.addCommand(createLogoutCommand());
+program.command("init [project-name]").description("Initialize a new SaaS project").option("--mock", "Skip authentication (for development/testing)").action((projectName, options) => initCommand(projectName, options));
+program.command("list").description("List available features").action(listCommand);
+program.command("append").description("Add Shipd features to an existing Next.js project").option("--features <features>", "Comma-separated list of features to add (e.g., docs)").option("--dry-run", "Preview changes without applying them").action((options) => appendCommand(options));
+async function interactiveMode() {
+  console.log(SHIPD_ASCII);
+  console.log("Welcome to Shipd! \u{1F680}\n");
+  const { action } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "What would you like to do?",
+      choices: [
+        { name: "\u{1F195} Initialize a new SaaS project", value: "init" },
+        { name: "\u2795 Add features to an existing project", value: "append" },
+        { name: "\u{1F4CB} List available features", value: "list" },
+        { name: "\u274C Exit", value: "exit" }
+      ]
+    }
+  ]);
+  if (action === "init") {
+    await initCommand(void 0, {});
+  } else if (action === "append") {
+    await appendCommand({});
+  } else if (action === "list") {
+    await listCommand();
+  } else {
+    console.log("Goodbye! \u{1F44B}");
+    process.exit(0);
+  }
+}
+var args = process.argv.slice(2);
+if (args.length === 0 || args.length === 1 && (args[0] === "--help" || args[0] === "-h")) {
+  if (args.length === 0) {
+    interactiveMode().catch((error) => {
+      console.error("Error:", error.message);
+      process.exit(1);
+    });
+  } else {
+    program.parse();
+  }
+} else {
+  program.parse();
+}