@svton/cli 1.0.0

package/dist/index.mjs

@@ -0,0 +1,722 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/create.ts
+import inquirer from "inquirer";
+import chalk2 from "chalk";
+import ora from "ora";
+import fs3 from "fs-extra";
+import path2 from "path";
+import validateNpmPackageName from "validate-npm-package-name";
+
+// src/utils/template.ts
+import fs2 from "fs-extra";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (message) => {
+    console.log(message);
+  },
+  success: (message) => {
+    console.log(chalk.green(message));
+  },
+  warn: (message) => {
+    console.log(chalk.yellow(message));
+  },
+  error: (message) => {
+    console.log(chalk.red(message));
+  },
+  debug: (message) => {
+    if (process.env.DEBUG) {
+      console.log(chalk.gray(`[DEBUG] ${message}`));
+    }
+  }
+};
+
+// src/utils/copy-template.ts
+import fs from "fs-extra";
+import path from "path";
+async function copyTemplateFiles(config) {
+  const { template, projectPath } = config;
+  const cliDir = path.dirname(path.dirname(__dirname));
+  const frameworkRoot = path.dirname(path.dirname(cliDir));
+  const templateDir = path.join(frameworkRoot, "templates");
+  logger.debug(`Copying template files from: ${templateDir}`);
+  if (!await fs.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 = path.join(sourceDir, "apps/backend");
+  const destPath = "apps/backend";
+  await fs.ensureDir(destPath);
+  await fs.copy(sourcePath, destPath, {
+    filter: (src) => {
+      const relativePath = path.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 = path.join(sourceDir, "apps/admin");
+  const destPath = "apps/admin";
+  await fs.ensureDir(destPath);
+  await fs.copy(sourcePath, destPath, {
+    filter: (src) => {
+      const relativePath = path.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 = path.join(sourceDir, "apps/mobile");
+  const destPath = "apps/mobile";
+  await fs.ensureDir(destPath);
+  await fs.copy(sourcePath, destPath, {
+    filter: (src) => {
+      const relativePath = path.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 = path.join(sourceDir, "packages/types");
+  const destPath = "packages/types";
+  await fs.ensureDir(destPath);
+  await fs.copy(sourcePath, destPath, {
+    filter: (src) => {
+      const relativePath = path.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 fs.readFile(filePath, "utf8");
+      content = content.replace(/@svton\//g, `${orgName}/`).replace(/community-next/g, projectName).replace(/community-helper/g, projectName).replace(/社区助手/g, projectName);
+      await fs.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 fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await traverse(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.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 fs.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 fs.writeJson(path.join(dir, "package.json"), packageJson, { spaces: 2 });
+}
+async function createMinimalAdmin(config) {
+  const dir = "apps/admin";
+  await fs.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 fs.writeJson(path.join(dir, "package.json"), packageJson, { spaces: 2 });
+}
+async function createMinimalMobile(config) {
+  const dir = "apps/mobile";
+  await fs.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 fs.writeJson(path.join(dir, "package.json"), packageJson, { spaces: 2 });
+}
+async function createMinimalTypes(config) {
+  const dir = "packages/types";
+  await fs.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 fs.writeJson(path.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 fs2.writeJson("package.json", packageJson, { spaces: 2 });
+  const workspaceConfig = `packages:
+  - 'apps/*'
+  - 'packages/*'
+`;
+  await fs2.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 fs2.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 fs2.writeFile(".gitignore", gitignore);
+  const npmrc = `auto-install-peers=true
+strict-peer-dependencies=false
+`;
+  await fs2.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 fs2.writeFile("docker-compose.yml", dockerCompose);
+  const readme = await generateReadme(config);
+  await fs2.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
+import { execSync } from "child_process";
+async function installDependencies(packageManager) {
+  try {
+    const command = getInstallCommand(packageManager);
+    logger.debug(`Running: ${command}`);
+    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
+import { execSync as execSync2 } from "child_process";
+async function initGit(projectName) {
+  try {
+    try {
+      execSync2("git status", { stdio: "ignore" });
+      logger.debug("Git repository already exists, skipping initialization");
+      return;
+    } catch {
+    }
+    execSync2("git init", { stdio: "ignore" });
+    execSync2("git add .", { stdio: "ignore" });
+    execSync2(`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 = validateNpmPackageName(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 = path2.resolve(process.cwd(), projectName);
+    if (await fs3.pathExists(projectPath)) {
+      logger.error(`Directory ${projectName} already exists!`);
+      process.exit(1);
+    }
+    logger.info(chalk2.blue("\u{1F680} Welcome to Svton App Generator!"));
+    logger.info("");
+    const answers = await inquirer.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(chalk2.cyan("\u{1F4CB} Project Configuration:"));
+    logger.info(`  Project Name: ${chalk2.white(config.projectName)}`);
+    logger.info(`  Organization: ${chalk2.white(config.orgName)}`);
+    logger.info(`  Template: ${chalk2.white(config.template)}`);
+    logger.info(`  Package Manager: ${chalk2.white(config.packageManager)}`);
+    logger.info(`  Install Dependencies: ${chalk2.white(config.installDeps ? "Yes" : "No")}`);
+    logger.info(`  Initialize Git: ${chalk2.white(config.initGit ? "Yes" : "No")}`);
+    logger.info("");
+    const { proceed } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "Proceed with project creation?",
+        default: true
+      }
+    ]);
+    if (!proceed) {
+      logger.info(chalk2.yellow("Project creation cancelled."));
+      return;
+    }
+    await createProjectFromTemplate(config);
+    logger.info("");
+    logger.success(chalk2.green("\u{1F389} Project created successfully!"));
+    logger.info("");
+    logger.info(chalk2.cyan("Next steps:"));
+    logger.info(`  ${chalk2.gray("$")} cd ${projectName}`);
+    if (!config.installDeps) {
+      logger.info(`  ${chalk2.gray("$")} ${config.packageManager} install`);
+    }
+    if (config.template === "full-stack" || config.template === "backend-only") {
+      logger.info(`  ${chalk2.gray("$")} docker-compose up -d`);
+      logger.info(`  ${chalk2.gray("$")} ${config.packageManager} --filter ${config.orgName}/backend prisma:generate`);
+      logger.info(`  ${chalk2.gray("$")} ${config.packageManager} --filter ${config.orgName}/backend prisma:migrate`);
+    }
+    logger.info(`  ${chalk2.gray("$")} ${config.packageManager} dev`);
+    logger.info("");
+    logger.info(chalk2.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 = ora("Creating project...").start();
+  try {
+    await fs3.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 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();
+}
+export {
+  cli
+};