@svton/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,750 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  cli: () => cli
+});
+module.exports = __toCommonJS(index_exports);
+var import_commander = require("commander");
+
+// src/commands/create.ts
+var import_inquirer = __toESM(require("inquirer"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_path2 = __toESM(require("path"));
+var import_validate_npm_package_name = __toESM(require("validate-npm-package-name"));
+
+// src/utils/template.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var logger = {
+  info: (message) => {
+    console.log(message);
+  },
+  success: (message) => {
+    console.log(import_chalk.default.green(message));
+  },
+  warn: (message) => {
+    console.log(import_chalk.default.yellow(message));
+  },
+  error: (message) => {
+    console.log(import_chalk.default.red(message));
+  },
+  debug: (message) => {
+    if (process.env.DEBUG) {
+      console.log(import_chalk.default.gray(`[DEBUG] ${message}`));
+    }
+  }
+};
+
+// src/utils/copy-template.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+async function copyTemplateFiles(config) {
+  const { template, projectPath } = config;
+  const cliDir = import_path.default.dirname(import_path.default.dirname(__dirname));
+  const frameworkRoot = import_path.default.dirname(import_path.default.dirname(cliDir));
+  const templateDir = import_path.default.join(frameworkRoot, "templates");
+  logger.debug(`Copying template files from: ${templateDir}`);
+  if (!await import_fs_extra.default.pathExists(templateDir)) {
+    logger.warn("Template directory not found, using built-in minimal templates");
+    await copyBuiltInTemplates(config);
+    return;
+  }
+  const originalCwd = process.cwd();
+  process.chdir(projectPath);
+  try {
+    switch (template) {
+      case "full-stack":
+        await copyBackendTemplate(templateDir, config);
+        await copyAdminTemplate(templateDir, config);
+        await copyMobileTemplate(templateDir, config);
+        await copyTypesTemplate(templateDir, config);
+        break;
+      case "backend-only":
+        await copyBackendTemplate(templateDir, config);
+        await copyTypesTemplate(templateDir, config);
+        break;
+      case "admin-only":
+        await copyAdminTemplate(templateDir, config);
+        await copyTypesTemplate(templateDir, config);
+        break;
+      case "mobile-only":
+        await copyMobileTemplate(templateDir, config);
+        await copyTypesTemplate(templateDir, config);
+        break;
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+async function copyBackendTemplate(sourceDir, config) {
+  const sourcePath = import_path.default.join(sourceDir, "apps/backend");
+  const destPath = "apps/backend";
+  await import_fs_extra.default.ensureDir(destPath);
+  await import_fs_extra.default.copy(sourcePath, destPath, {
+    filter: (src) => {
+      const relativePath = import_path.default.relative(sourcePath, src);
+      return !relativePath.includes("node_modules") && !relativePath.includes("dist") && !relativePath.includes(".env") && !relativePath.includes(".env.local");
+    }
+  });
+  await replacePackageNames(destPath, config);
+  logger.debug("Backend template copied");
+}
+async function copyAdminTemplate(sourceDir, config) {
+  const sourcePath = import_path.default.join(sourceDir, "apps/admin");
+  const destPath = "apps/admin";
+  await import_fs_extra.default.ensureDir(destPath);
+  await import_fs_extra.default.copy(sourcePath, destPath, {
+    filter: (src) => {
+      const relativePath = import_path.default.relative(sourcePath, src);
+      return !relativePath.includes("node_modules") && !relativePath.includes(".next") && !relativePath.includes(".env.local");
+    }
+  });
+  await replacePackageNames(destPath, config);
+  logger.debug("Admin template copied");
+}
+async function copyMobileTemplate(sourceDir, config) {
+  const sourcePath = import_path.default.join(sourceDir, "apps/mobile");
+  const destPath = "apps/mobile";
+  await import_fs_extra.default.ensureDir(destPath);
+  await import_fs_extra.default.copy(sourcePath, destPath, {
+    filter: (src) => {
+      const relativePath = import_path.default.relative(sourcePath, src);
+      return !relativePath.includes("node_modules") && !relativePath.includes("dist");
+    }
+  });
+  await replacePackageNames(destPath, config);
+  logger.debug("Mobile template copied");
+}
+async function copyTypesTemplate(sourceDir, config) {
+  const sourcePath = import_path.default.join(sourceDir, "packages/types");
+  const destPath = "packages/types";
+  await import_fs_extra.default.ensureDir(destPath);
+  await import_fs_extra.default.copy(sourcePath, destPath, {
+    filter: (src) => {
+      const relativePath = import_path.default.relative(sourcePath, src);
+      return !relativePath.includes("node_modules") && !relativePath.includes("dist");
+    }
+  });
+  await replacePackageNames(destPath, config);
+  logger.debug("Types package copied");
+}
+async function replacePackageNames(directory, config) {
+  const { projectName, orgName } = config;
+  const filesToUpdate = await findFilesToUpdate(directory);
+  for (const filePath of filesToUpdate) {
+    try {
+      let content = await import_fs_extra.default.readFile(filePath, "utf8");
+      content = content.replace(/@svton\//g, `${orgName}/`).replace(/community-next/g, projectName).replace(/community-helper/g, projectName).replace(/社区助手/g, projectName);
+      await import_fs_extra.default.writeFile(filePath, content);
+    } catch (error) {
+      logger.debug(`Failed to update file ${filePath}: ${error}`);
+    }
+  }
+}
+async function findFilesToUpdate(directory) {
+  const files = [];
+  const traverse = async (dir) => {
+    const entries = await import_fs_extra.default.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = import_path.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await traverse(fullPath);
+      } else if (entry.isFile()) {
+        const ext = import_path.default.extname(entry.name);
+        const shouldUpdate = [".json", ".ts", ".tsx", ".js", ".jsx", ".md", ".yaml", ".yml", ".env.example"].includes(ext);
+        if (shouldUpdate) {
+          files.push(fullPath);
+        }
+      }
+    }
+  };
+  await traverse(directory);
+  return files;
+}
+async function copyBuiltInTemplates(config) {
+  logger.info("Creating minimal project structure...");
+  const { template } = config;
+  if (template === "full-stack" || template === "backend-only") {
+    await createMinimalBackend(config);
+  }
+  if (template === "full-stack" || template === "admin-only") {
+    await createMinimalAdmin(config);
+  }
+  if (template === "full-stack" || template === "mobile-only") {
+    await createMinimalMobile(config);
+  }
+  await createMinimalTypes(config);
+}
+async function createMinimalBackend(config) {
+  const dir = "apps/backend";
+  await import_fs_extra.default.ensureDir(dir);
+  const packageJson = {
+    name: `${config.orgName}/backend`,
+    version: "1.0.0",
+    description: "Backend API server",
+    scripts: {
+      build: "nest build",
+      dev: "nest start --watch",
+      start: "node dist/main",
+      lint: 'eslint "src/**/*.{ts,tsx}"',
+      "type-check": "tsc --noEmit"
+    },
+    dependencies: {
+      "@nestjs/common": "^10.3.0",
+      "@nestjs/core": "^10.3.0",
+      "@nestjs/platform-express": "^10.3.0",
+      "reflect-metadata": "^0.2.1",
+      "rxjs": "^7.8.1"
+    },
+    devDependencies: {
+      "@nestjs/cli": "^10.2.1",
+      "@types/node": "^20.10.0",
+      "typescript": "^5.3.0"
+    }
+  };
+  await import_fs_extra.default.writeJson(import_path.default.join(dir, "package.json"), packageJson, { spaces: 2 });
+}
+async function createMinimalAdmin(config) {
+  const dir = "apps/admin";
+  await import_fs_extra.default.ensureDir(dir);
+  const packageJson = {
+    name: `${config.orgName}/admin`,
+    version: "1.0.0",
+    description: "Admin panel",
+    scripts: {
+      dev: "next dev -p 3001",
+      build: "next build",
+      start: "next start -p 3001",
+      lint: "next lint",
+      "type-check": "tsc --noEmit"
+    },
+    dependencies: {
+      "next": "^15.5.0",
+      "react": "^19.0.0",
+      "react-dom": "^19.0.0"
+    },
+    devDependencies: {
+      "@types/node": "^22.10.2",
+      "@types/react": "^19.0.2",
+      "@types/react-dom": "^19.0.2",
+      "typescript": "^5.7.3"
+    }
+  };
+  await import_fs_extra.default.writeJson(import_path.default.join(dir, "package.json"), packageJson, { spaces: 2 });
+}
+async function createMinimalMobile(config) {
+  const dir = "apps/mobile";
+  await import_fs_extra.default.ensureDir(dir);
+  const packageJson = {
+    name: `${config.orgName}/mobile`,
+    version: "1.0.0",
+    description: "Mobile application",
+    scripts: {
+      "build:weapp": "taro build --type weapp",
+      "dev:weapp": "taro build --type weapp --watch",
+      dev: "npm run dev:weapp",
+      lint: 'eslint "src/**/*.{ts,tsx}"',
+      "type-check": "tsc --noEmit"
+    },
+    dependencies: {
+      "@tarojs/components": "3.6.23",
+      "@tarojs/runtime": "3.6.23",
+      "@tarojs/taro": "3.6.23",
+      "@tarojs/react": "3.6.23",
+      "react": "^18.2.0"
+    },
+    devDependencies: {
+      "@tarojs/cli": "3.6.23",
+      "@types/react": "^18.2.45",
+      "typescript": "^5.3.3"
+    }
+  };
+  await import_fs_extra.default.writeJson(import_path.default.join(dir, "package.json"), packageJson, { spaces: 2 });
+}
+async function createMinimalTypes(config) {
+  const dir = "packages/types";
+  await import_fs_extra.default.ensureDir(dir);
+  const packageJson = {
+    name: `${config.orgName}/types`,
+    version: "1.0.0",
+    description: "Shared type definitions",
+    main: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    scripts: {
+      build: "tsup src/index.ts --format cjs,esm --dts",
+      dev: "tsup src/index.ts --format cjs,esm --dts --watch",
+      "type-check": "tsc --noEmit"
+    },
+    devDependencies: {
+      "tsup": "^8.0.1",
+      "typescript": "^5.3.3"
+    }
+  };
+  await import_fs_extra.default.writeJson(import_path.default.join(dir, "package.json"), packageJson, { spaces: 2 });
+}
+
+// src/utils/template.ts
+async function generateFromTemplate(config) {
+  await createRootFiles(config);
+  await copyTemplateFiles({
+    projectName: config.projectName,
+    orgName: config.orgName,
+    template: config.template,
+    projectPath: config.projectPath
+  });
+}
+async function createRootFiles(config) {
+  const { projectName, orgName, packageManager } = config;
+  const packageJson = {
+    name: projectName,
+    version: "1.0.0",
+    private: true,
+    description: `Full-stack application based on Svton architecture`,
+    scripts: {
+      dev: "turbo run dev",
+      [`dev:backend`]: `turbo run dev --filter=${orgName}/backend`,
+      [`dev:admin`]: `turbo run dev --filter=${orgName}/admin`,
+      [`dev:mobile`]: `turbo run dev --filter=${orgName}/mobile`,
+      build: "turbo run build",
+      lint: "turbo run lint",
+      "type-check": "turbo run type-check",
+      clean: "turbo run clean && rm -rf node_modules"
+    },
+    devDependencies: {
+      turbo: "^1.11.0",
+      typescript: "^5.3.0",
+      "@types/node": "^20.10.0",
+      prettier: "^3.1.0",
+      eslint: "^8.55.0"
+    },
+    packageManager: `${packageManager}@8.12.0`,
+    engines: {
+      node: ">=18.0.0",
+      pnpm: ">=8.0.0"
+    }
+  };
+  await import_fs_extra2.default.writeJson("package.json", packageJson, { spaces: 2 });
+  const workspaceConfig = `packages:
+  - 'apps/*'
+  - 'packages/*'
+`;
+  await import_fs_extra2.default.writeFile("pnpm-workspace.yaml", workspaceConfig);
+  const turboConfig = {
+    "$schema": "https://turbo.build/schema.json",
+    pipeline: {
+      build: {
+        dependsOn: ["^build"],
+        outputs: ["dist/**", ".next/**", "build/**"]
+      },
+      dev: {
+        cache: false,
+        persistent: true
+      },
+      lint: {
+        outputs: []
+      },
+      "type-check": {
+        dependsOn: ["^build"],
+        outputs: []
+      },
+      clean: {
+        cache: false
+      }
+    }
+  };
+  await import_fs_extra2.default.writeJson("turbo.json", turboConfig, { spaces: 2 });
+  const gitignore = `# Dependencies
+node_modules/
+.pnpm-store/
+
+# Build outputs
+dist/
+build/
+.next/
+.turbo/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Testing
+coverage/
+
+# Misc
+*.tsbuildinfo
+`;
+  await import_fs_extra2.default.writeFile(".gitignore", gitignore);
+  const npmrc = `auto-install-peers=true
+strict-peer-dependencies=false
+`;
+  await import_fs_extra2.default.writeFile(".npmrc", npmrc);
+  const dockerCompose = `version: '3.8'
+
+services:
+  mysql:
+    image: mysql:8.0
+    container_name: ${projectName}-mysql
+    restart: unless-stopped
+    environment:
+      MYSQL_ROOT_PASSWORD: root123456
+      MYSQL_DATABASE: ${projectName}
+      MYSQL_USER: ${projectName}
+      MYSQL_PASSWORD: ${projectName}123456
+    ports:
+      - '3306:3306'
+    volumes:
+      - mysql_data:/var/lib/mysql
+    command: --default-authentication-plugin=mysql_native_password
+
+  redis:
+    image: redis:7-alpine
+    container_name: ${projectName}-redis
+    restart: unless-stopped
+    ports:
+      - '6379:6379'
+    volumes:
+      - redis_data:/data
+
+volumes:
+  mysql_data:
+  redis_data:
+`;
+  await import_fs_extra2.default.writeFile("docker-compose.yml", dockerCompose);
+  const readme = await generateReadme(config);
+  await import_fs_extra2.default.writeFile("README.md", readme);
+}
+async function generateReadme(config) {
+  const { projectName, orgName, template } = config;
+  return `# ${projectName}
+
+> Based on Svton architecture - Full-stack application
+
+## \u{1F680} Quick Start
+
+### Prerequisites
+
+- Node.js >= 18.0.0
+- pnpm >= 8.0.0
+- Docker (for MySQL and Redis)
+
+### Installation
+
+\`\`\`bash
+# Install dependencies
+pnpm install
+
+# Start databases
+docker-compose up -d
+
+# Configure environment variables
+cp apps/backend/.env.example apps/backend/.env
+
+# Generate Prisma client
+pnpm --filter ${orgName}/backend prisma:generate
+
+# Run database migrations
+pnpm --filter ${orgName}/backend prisma:migrate
+
+# Start development servers
+pnpm dev
+\`\`\`
+
+### Services
+
+| Service | URL |
+|---------|-----|
+| Backend API | http://localhost:3000 |
+| Admin Panel | http://localhost:3001 |
+| API Docs | http://localhost:3000/api-docs |
+
+## \u{1F4C1} Project Structure
+
+\`\`\`
+${projectName}/
+\u251C\u2500\u2500 apps/
+${template === "full-stack" || template === "backend-only" ? "\u2502   \u251C\u2500\u2500 backend/        # " + orgName + "/backend - NestJS API" : ""}
+${template === "full-stack" || template === "admin-only" ? "\u2502   \u251C\u2500\u2500 admin/          # " + orgName + "/admin - Next.js Admin Panel" : ""}
+${template === "full-stack" || template === "mobile-only" ? "\u2502   \u2514\u2500\u2500 mobile/         # " + orgName + "/mobile - Taro Mini Program" : ""}
+\u251C\u2500\u2500 packages/
+\u2502   \u2514\u2500\u2500 types/          # ${orgName}/types - Shared Type Definitions
+\u251C\u2500\u2500 package.json
+\u251C\u2500\u2500 pnpm-workspace.yaml
+\u251C\u2500\u2500 turbo.json
+\u2514\u2500\u2500 docker-compose.yml
+\`\`\`
+
+## \u{1F6E0}\uFE0F Commands
+
+\`\`\`bash
+pnpm dev              # Start all services
+pnpm dev:backend      # Start backend only
+pnpm dev:admin        # Start admin panel only
+pnpm dev:mobile       # Start mobile app only
+pnpm build            # Build all projects
+pnpm lint             # Run linting
+pnpm clean            # Clean build artifacts
+\`\`\`
+
+## \u{1F4DA} Documentation
+
+- [Svton Architecture](https://github.com/svton/svton)
+
+---
+
+Generated with \`create-svton-app\`
+`;
+}
+
+// src/utils/install.ts
+var import_child_process = require("child_process");
+async function installDependencies(packageManager) {
+  try {
+    const command = getInstallCommand(packageManager);
+    logger.debug(`Running: ${command}`);
+    (0, import_child_process.execSync)(command, {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+  } catch (error) {
+    throw new Error(`Failed to install dependencies with ${packageManager}`);
+  }
+}
+function getInstallCommand(packageManager) {
+  switch (packageManager) {
+    case "npm":
+      return "npm install";
+    case "yarn":
+      return "yarn install";
+    case "pnpm":
+      return "pnpm install";
+    default:
+      throw new Error(`Unsupported package manager: ${packageManager}`);
+  }
+}
+
+// src/utils/git.ts
+var import_child_process2 = require("child_process");
+async function initGit(projectName) {
+  try {
+    try {
+      (0, import_child_process2.execSync)("git status", { stdio: "ignore" });
+      logger.debug("Git repository already exists, skipping initialization");
+      return;
+    } catch {
+    }
+    (0, import_child_process2.execSync)("git init", { stdio: "ignore" });
+    (0, import_child_process2.execSync)("git add .", { stdio: "ignore" });
+    (0, import_child_process2.execSync)(`git commit -m "feat: initialize ${projectName} project"`, {
+      stdio: "ignore"
+    });
+    logger.debug("Git repository initialized successfully");
+  } catch (error) {
+    logger.warn("Failed to initialize Git repository");
+    logger.debug(error instanceof Error ? error.message : String(error));
+  }
+}
+
+// src/commands/create.ts
+async function createProject(projectName, options = {}) {
+  try {
+    const validation = (0, import_validate_npm_package_name.default)(projectName);
+    if (!validation.validForNewPackages) {
+      logger.error(`Invalid project name: ${projectName}`);
+      if (validation.errors) {
+        validation.errors.forEach((error) => logger.error(`- ${error}`));
+      }
+      process.exit(1);
+    }
+    const projectPath = import_path2.default.resolve(process.cwd(), projectName);
+    if (await import_fs_extra3.default.pathExists(projectPath)) {
+      logger.error(`Directory ${projectName} already exists!`);
+      process.exit(1);
+    }
+    logger.info(import_chalk2.default.blue("\u{1F680} Welcome to Svton App Generator!"));
+    logger.info("");
+    const answers = await import_inquirer.default.prompt([
+      {
+        type: "input",
+        name: "org",
+        message: "Organization name (will be used as @org/package-name):",
+        default: options.org || projectName,
+        validate: (input) => {
+          if (!input.trim()) return "Organization name is required";
+          return true;
+        }
+      },
+      {
+        type: "list",
+        name: "template",
+        message: "Choose a template:",
+        choices: [
+          { name: "Full Stack (Backend + Admin + Mobile)", value: "full-stack" },
+          { name: "Backend Only (NestJS + Prisma)", value: "backend-only" },
+          { name: "Admin Only (Next.js)", value: "admin-only" },
+          { name: "Mobile Only (Taro)", value: "mobile-only" }
+        ],
+        default: options.template || "full-stack"
+      },
+      {
+        type: "list",
+        name: "packageManager",
+        message: "Package manager:",
+        choices: ["pnpm", "npm", "yarn"],
+        default: options.packageManager || "pnpm"
+      },
+      {
+        type: "confirm",
+        name: "installDeps",
+        message: "Install dependencies?",
+        default: !options.skipInstall
+      },
+      {
+        type: "confirm",
+        name: "initGit",
+        message: "Initialize Git repository?",
+        default: !options.skipGit
+      }
+    ]);
+    const config = {
+      projectName,
+      orgName: answers.org.startsWith("@") ? answers.org : `@${answers.org}`,
+      template: answers.template,
+      packageManager: answers.packageManager,
+      installDeps: answers.installDeps,
+      initGit: answers.initGit,
+      projectPath
+    };
+    logger.info("");
+    logger.info(import_chalk2.default.cyan("\u{1F4CB} Project Configuration:"));
+    logger.info(`  Project Name: ${import_chalk2.default.white(config.projectName)}`);
+    logger.info(`  Organization: ${import_chalk2.default.white(config.orgName)}`);
+    logger.info(`  Template: ${import_chalk2.default.white(config.template)}`);
+    logger.info(`  Package Manager: ${import_chalk2.default.white(config.packageManager)}`);
+    logger.info(`  Install Dependencies: ${import_chalk2.default.white(config.installDeps ? "Yes" : "No")}`);
+    logger.info(`  Initialize Git: ${import_chalk2.default.white(config.initGit ? "Yes" : "No")}`);
+    logger.info("");
+    const { proceed } = await import_inquirer.default.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "Proceed with project creation?",
+        default: true
+      }
+    ]);
+    if (!proceed) {
+      logger.info(import_chalk2.default.yellow("Project creation cancelled."));
+      return;
+    }
+    await createProjectFromTemplate(config);
+    logger.info("");
+    logger.success(import_chalk2.default.green("\u{1F389} Project created successfully!"));
+    logger.info("");
+    logger.info(import_chalk2.default.cyan("Next steps:"));
+    logger.info(`  ${import_chalk2.default.gray("$")} cd ${projectName}`);
+    if (!config.installDeps) {
+      logger.info(`  ${import_chalk2.default.gray("$")} ${config.packageManager} install`);
+    }
+    if (config.template === "full-stack" || config.template === "backend-only") {
+      logger.info(`  ${import_chalk2.default.gray("$")} docker-compose up -d`);
+      logger.info(`  ${import_chalk2.default.gray("$")} ${config.packageManager} --filter ${config.orgName}/backend prisma:generate`);
+      logger.info(`  ${import_chalk2.default.gray("$")} ${config.packageManager} --filter ${config.orgName}/backend prisma:migrate`);
+    }
+    logger.info(`  ${import_chalk2.default.gray("$")} ${config.packageManager} dev`);
+    logger.info("");
+    logger.info(import_chalk2.default.gray("Happy coding! \u{1F680}"));
+  } catch (error) {
+    logger.error("Failed to create project:");
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+async function createProjectFromTemplate(config) {
+  const spinner = (0, import_ora.default)("Creating project...").start();
+  try {
+    await import_fs_extra3.default.ensureDir(config.projectPath);
+    process.chdir(config.projectPath);
+    spinner.text = "Generating project files...";
+    await generateFromTemplate(config);
+    if (config.installDeps) {
+      spinner.text = "Installing dependencies...";
+      await installDependencies(config.packageManager);
+    }
+    if (config.initGit) {
+      spinner.text = "Initializing Git repository...";
+      await initGit(config.projectName);
+    }
+    spinner.succeed("Project created successfully!");
+  } catch (error) {
+    spinner.fail("Failed to create project");
+    throw error;
+  }
+}
+
+// package.json
+var version = "1.0.0";
+
+// src/index.ts
+function cli() {
+  const program = new import_commander.Command();
+  program.name("svton").description("Svton CLI - Create full-stack applications with NestJS, Next.js, and Taro").version(version);
+  program.command("create <project-name>").alias("init").alias("new").description("Create a new Svton project").option("-o, --org <name>", "Organization name (default: project name)").option("--skip-install", "Skip installing dependencies").option("--skip-git", "Skip Git initialization").option("-t, --template <template>", "Template to use", "full-stack").option("-p, --package-manager <pm>", "Package manager to use", "pnpm").action(createProject);
+  program.parse();
+}
+if (require.main === module) {
+  cli();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cli
+});