yf-system-cli 1.0.0

package/src/commands/init.js

@@ -0,0 +1,699 @@
+// src/commands/init.js
+const { program } = require("commander");
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const ora = require("ora");
+const fs = require("fs-extra");
+const path = require("path");
+const { getConfig } = require("../config");
+
+program
+  .command("init <project-name>")
+  .description("初始化一个新项目")
+  .option("-t, --template <template>", "指定模板名称 (application/theme)")
+  .option("-f, --force", "强制覆盖已存在的目录")
+  .option("--skip-conflict-check", "跳过文件冲突检查")
+  .option("--type <type>", "指定项目类型 (application/theme)，如果不指定则根据模板类型自动判断")
+  .action(async (projectName, options) => {
+    try {
+      console.log(chalk.cyan("\n🚀 开始创建项目...\n"));
+
+      // 1. 验证项目名称
+      validateProjectName(projectName);
+
+      // 2. 选择模板
+      const templateName = options.template || (await selectTemplate());
+
+      // 3. 确定项目类型
+      const projectType = await determineProjectType(templateName, options.type);
+
+      // 4. 获取目标目录
+      const targetDir = await getTargetDirectory(projectName, projectType);
+
+      // 5. 检查目录是否存在
+      await checkAndHandleExistingDir(targetDir);
+
+      // 6. 获取模板路径
+      const templatePath = getTemplatePath(templateName);
+      if (!fs.existsSync(templatePath)) {
+        throw new Error(`模板 "${templateName}" 不存在，请检查模板目录`);
+      }
+
+      // 7. 创建项目目录
+      fs.ensureDirSync(targetDir);
+
+      // 8. 检查文件冲突
+      const conflicts = await checkFileConflicts(templatePath, targetDir);
+      if (conflicts.length > 0 && !options.skipConflictCheck) {
+        const conflictAction = await handleFileConflicts(conflicts, targetDir, projectName);
+        options.conflictAction = conflictAction;
+      }
+
+      // 9. 拷贝模板文件
+      await copyTemplateFiles(templatePath, targetDir, projectName, conflicts, options);
+
+      // 10. 显示成功信息
+      showSuccessInfo(targetDir, projectName, templateName, projectType);
+    } catch (error) {
+      console.error(chalk.red("\n❌ 创建项目失败:"), error.message);
+      process.exit(1);
+    }
+  });
+
+// 验证项目名称
+function validateProjectName(name) {
+  if (!name || name.trim() === "") {
+    throw new Error("项目名称不能为空");
+  }
+
+  const invalidChars = /[<>:"/\\|?*\x00-\x1F]/;
+  if (invalidChars.test(name)) {
+    throw new Error("项目名称包含非法字符");
+  }
+}
+
+// 确定项目类型
+async function determineProjectType(templateName, specifiedType) {
+  // 如果用户指定了类型，使用指定类型
+  if (specifiedType) {
+    if (!["application", "theme"].includes(specifiedType.toLowerCase())) {
+      throw new Error("项目类型必须是 'application' 或 'theme'");
+    }
+    return specifiedType.toLowerCase();
+  }
+
+  // 根据模板名称判断类型
+  const templateType = getTemplateType(templateName);
+
+  // 如果模板类型明确，使用模板类型
+  if (templateType) {
+    return templateType;
+  }
+
+  // 如果无法自动判断，询问用户
+  const { projectType } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "projectType",
+      message: "请选择项目类型:",
+      choices: [
+        { name: "应用", value: "application" },
+        { name: "主题", value: "theme" },
+      ],
+    },
+  ]);
+
+  return projectType;
+}
+
+// 根据模板名称获取模板类型
+function getTemplateType(templateName) {
+  const templateConfig = getTemplateConfig(templateName);
+
+  // 如果模板配置中有类型定义，使用配置的类型
+  if (templateConfig && templateConfig.type) {
+    return templateConfig.type;
+  }
+
+  // 根据模板名称关键字判断
+  const name = templateName.toLowerCase();
+
+  if (name.includes("theme") || name.includes("skin") || name.includes("ui") || name.includes("template") || name.includes("样式")) {
+    return "theme";
+  }
+
+  if (name.includes("app") || name.includes("application") || name.includes("project") || name.includes("应用")) {
+    return "application";
+  }
+
+  // 无法判断时返回 null
+  return null;
+}
+
+// 获取模板配置
+function getTemplateConfig(templateName) {
+  const config = getConfig();
+
+  // 检查配置中的模板设置
+  if (config.templates && config.templates[templateName]) {
+    return config.templates[templateName];
+  }
+
+  // 检查内置模板的配置文件
+  const templatesDir = path.join(__dirname, "../../templates");
+  const templatePath = path.join(templatesDir, templateName);
+
+  if (fs.existsSync(templatePath)) {
+    const configFile = path.join(templatePath, "template.config.json");
+    if (fs.existsSync(configFile)) {
+      try {
+        return fs.readJsonSync(configFile);
+      } catch (error) {
+        // 配置文件读取失败，返回空配置
+      }
+    }
+  }
+
+  return null;
+}
+
+// 获取目标目录
+async function getTargetDirectory(projectName, projectType) {
+  const config = getConfig();
+  let baseDir = process.cwd();
+
+  // 检查配置中是否有项目目录设置
+  if (config.projectDirs && config.projectDirs[projectType]) {
+    baseDir = path.resolve(config.projectDirs[projectType]);
+  }
+
+  // 确保基础目录存在
+  fs.ensureDirSync(baseDir);
+
+  // 根据项目类型创建子目录
+  let typeDir;
+  switch (projectType) {
+    case "application":
+      typeDir = path.join(baseDir, "src", "applications");
+      break;
+    case "theme":
+      typeDir = path.join(baseDir, "src", "themes");
+      break;
+    default:
+      typeDir = baseDir;
+  }
+
+  // 创建类型目录
+  fs.ensureDirSync(typeDir);
+
+  // 检查是否已存在同名项目
+  const targetDir = path.join(typeDir, projectName);
+
+  return targetDir;
+}
+
+// 检查并处理已存在的目录
+async function checkAndHandleExistingDir(targetDir) {
+  if (fs.existsSync(targetDir)) {
+    throw new Error(`目录已存在: ${targetDir}`);
+  }
+}
+
+// 选择模板
+async function selectTemplate() {
+  // 检查内置模板
+  const templatesDir = path.join(__dirname, "../../templates");
+
+  // 确保模板目录存在
+  fs.ensureDirSync(templatesDir);
+
+  const builtinTemplates = fs.readdirSync(templatesDir).filter((item) => {
+    const itemPath = path.join(templatesDir, item);
+    return fs.statSync(itemPath).isDirectory();
+  });
+
+  if (builtinTemplates.length === 0) {
+    throw new Error("没有找到任何模板，请在 templates/ 目录下创建模板文件夹");
+  }
+
+  const { template } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "template",
+      message: "请选择项目模板:",
+      choices: builtinTemplates.map((t) => ({
+        name: getTemplateDisplayName(t),
+        value: t,
+      })),
+    },
+  ]);
+
+  return template;
+}
+
+// 获取模板显示名称
+function getTemplateDisplayName(template) {
+  const config = getTemplateConfig(template);
+
+  if (config && config.displayName) {
+    return `${template} - ${config.displayName}`;
+  }
+
+  const names = {
+    h5: "H5移动端项目",
+    node: "Node.js后端项目",
+    vue: "Vue 3前端项目",
+    react: "React 18前端项目",
+    default: "默认应用模板",
+    "admin-theme": "后台管理主题",
+    "mobile-theme": "移动端主题",
+  };
+
+  const displayName = names[template] || "自定义模板";
+  const type = getTemplateType(template);
+  const typeLabel = type === "theme" ? "[主题]" : "[应用]";
+
+  return `${typeLabel} ${template} - ${displayName}`;
+}
+
+// 获取模板路径
+function getTemplatePath(templateName) {
+  const templatesDir = path.join(__dirname, "../../templates");
+
+  // 先检查内置模板
+  const builtinPath = path.join(templatesDir, templateName);
+  if (fs.existsSync(builtinPath)) {
+    return builtinPath;
+  }
+
+  // 检查配置中的自定义模板
+  const config = getConfig();
+  if (config.templates && config.templates[templateName]) {
+    const customPath = config.templates[templateName].path;
+    if (customPath && fs.existsSync(customPath)) {
+      return customPath;
+    }
+  }
+
+  throw new Error(`找不到模板 "${templateName}"`);
+}
+
+// 检查文件冲突
+async function checkFileConflicts(sourceDir, targetDir) {
+  const conflicts = [];
+
+  // 递归检查所有文件
+  const checkDir = async (sourcePath, targetPath) => {
+    if (!fs.existsSync(sourcePath)) return;
+
+    const items = fs.readdirSync(sourcePath);
+
+    for (const item of items) {
+      const sourceItemPath = path.join(sourcePath, item);
+      const targetItemPath = path.join(targetPath, item);
+      const stats = fs.statSync(sourceItemPath);
+
+      if (stats.isDirectory()) {
+        // 检查是否需要过滤的目录
+        const ignoredDirs = ["node_modules", ".git", ".DS_Store", "Thumbs.db"];
+        if (ignoredDirs.includes(item)) {
+          continue;
+        }
+
+        // 递归检查子目录
+        await checkDir(sourceItemPath, targetItemPath);
+      } else {
+        // 检查文件是否已存在
+        if (fs.existsSync(targetItemPath)) {
+          conflicts.push({
+            source: sourceItemPath,
+            target: targetItemPath,
+            name: item,
+            relativePath: path.relative(targetDir, targetItemPath),
+            sourceSize: stats.size,
+            sourceMtime: stats.mtime,
+          });
+        }
+      }
+    }
+  };
+
+  await checkDir(sourceDir, targetDir);
+  return conflicts;
+}
+
+// 处理文件冲突
+async function handleFileConflicts(conflicts, targetDir, projectName) {
+  console.log(chalk.yellow("\n⚠️  检测到以下文件冲突:"));
+
+  conflicts.forEach((conflict, index) => {
+    console.log(chalk.red(`  ${index + 1}. ${conflict.relativePath}`));
+  });
+
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: `发现 ${conflicts.length} 个文件冲突，请选择处理方式:`,
+      choices: [
+        {
+          name: "跳过冲突文件（保留现有文件）",
+          value: "skip",
+        },
+        {
+          name: "覆盖所有冲突文件",
+          value: "overwrite-all",
+        },
+        {
+          name: "重命名冲突文件",
+          value: "rename",
+        },
+        {
+          name: "手动选择每个文件的处理方式",
+          value: "manual",
+        },
+        {
+          name: "取消创建项目",
+          value: "cancel",
+        },
+      ],
+    },
+  ]);
+
+  if (action === "cancel") {
+    throw new Error("用户取消操作");
+  }
+
+  return action;
+}
+
+// 处理单个文件冲突
+async function handleSingleConflict(conflict, targetDir, projectName) {
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: `如何处理文件 "${conflict.relativePath}"?`,
+      choices: [
+        { name: "跳过（保留现有文件）", value: "skip" },
+        { name: "覆盖", value: "overwrite" },
+        { name: "重命名", value: "rename" },
+        { name: "比较差异", value: "diff" },
+      ],
+    },
+  ]);
+
+  if (action === "rename") {
+    const { newName } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "newName",
+        message: `请输入新文件名 (原文件: ${conflict.name}):`,
+        default: `${path.basename(conflict.name, path.extname(conflict.name))}_new${path.extname(conflict.name)}`,
+        validate: (input) => {
+          if (!input || input.trim() === "") {
+            return "文件名不能为空";
+          }
+          const newPath = path.join(path.dirname(conflict.target), input);
+          if (fs.existsSync(newPath)) {
+            return "新文件名已存在，请重新输入";
+          }
+          return true;
+        },
+      },
+    ]);
+
+    return {
+      type: "rename",
+      originalPath: conflict.target,
+      newPath: path.join(path.dirname(conflict.target), newName),
+    };
+  } else if (action === "diff") {
+    // 显示文件差异（简化版本）
+    console.log(chalk.cyan(`\n📄 文件对比: ${conflict.relativePath}`));
+
+    let sourceContent = "",
+      targetContent = "";
+
+    try {
+      sourceContent = fs.readFileSync(conflict.source, "utf8");
+      targetContent = fs.readFileSync(conflict.target, "utf8");
+
+      console.log(chalk.green("模板文件内容:"));
+      console.log(sourceContent.substring(0, 200) + (sourceContent.length > 200 ? "..." : ""));
+      console.log(chalk.yellow("\n现有文件内容:"));
+      console.log(targetContent.substring(0, 200) + (targetContent.length > 200 ? "..." : ""));
+    } catch (error) {
+      console.log(chalk.red("无法读取文件内容"));
+    }
+
+    // 重新询问处理方式
+    return handleSingleConflict(conflict, targetDir, projectName);
+  }
+
+  return { type: action };
+}
+
+// 拷贝模板文件（增强版本）
+async function copyTemplateFiles(sourceDir, targetDir, projectName, conflicts = [], options = {}) {
+  const spinner = ora("正在拷贝模板文件...").start();
+
+  try {
+    // 记录要跳过的文件和重命名的文件
+    const skipFiles = new Set();
+    const renameMap = new Map();
+
+    // 如果是手动处理模式
+    if (options.conflictAction === "manual") {
+      for (const conflict of conflicts) {
+        const result = await handleSingleConflict(conflict, targetDir, projectName);
+
+        if (result.type === "skip") {
+          skipFiles.add(conflict.target);
+        } else if (result.type === "rename") {
+          skipFiles.add(conflict.target); // 原文件跳过
+          renameMap.set(conflict.source, result.newPath);
+        }
+        // overwrite 不需要特别处理，会正常覆盖
+      }
+    } else if (options.conflictAction === "skip") {
+      // 跳过所有冲突文件
+      conflicts.forEach((conflict) => {
+        skipFiles.add(conflict.target);
+      });
+    }
+    // overwrite-all 不需要特殊处理
+
+    // 递归拷贝文件
+    await copyWithConflicts(sourceDir, targetDir, skipFiles, renameMap);
+
+    spinner.succeed(chalk.green("✓ 模板文件拷贝完成"));
+
+    // 替换文件中的占位符（排除跳过的文件）
+    await replacePlaceholders(targetDir, projectName, skipFiles);
+  } catch (error) {
+    spinner.fail("拷贝模板文件失败");
+    throw error;
+  }
+}
+
+// 带冲突处理的拷贝函数
+async function copyWithConflicts(sourceDir, targetDir, skipFiles, renameMap) {
+  const items = fs.readdirSync(sourceDir);
+
+  for (const item of items) {
+    const sourcePath = path.join(sourceDir, item);
+    const targetPath = path.join(targetDir, item);
+    const stats = fs.statSync(sourcePath);
+
+    // 跳过不需要的文件
+    if (shouldSkipFile(item)) {
+      continue;
+    }
+
+    // 检查是否要重命名
+    const actualTargetPath = renameMap.get(sourcePath) || targetPath;
+
+    if (stats.isDirectory()) {
+      // 创建目录并递归拷贝
+      fs.ensureDirSync(actualTargetPath);
+      await copyWithConflicts(sourcePath, actualTargetPath, skipFiles, renameMap);
+    } else {
+      // 检查是否要跳过此文件
+      if (skipFiles.has(targetPath)) {
+        console.log(chalk.gray(`  跳过: ${path.relative(targetDir, targetPath)}`));
+        continue;
+      }
+
+      // 检查目标目录是否存在同名文件（防止冲突）
+      const targetDirPath = path.dirname(actualTargetPath);
+      const targetFileName = path.basename(actualTargetPath);
+
+      // 如果目标文件已存在且不在skip列表中，生成新文件名
+      if (fs.existsSync(actualTargetPath) && !skipFiles.has(actualTargetPath)) {
+        let counter = 1;
+        let newFileName, newFilePath;
+
+        do {
+          const ext = path.extname(targetFileName);
+          const name = path.basename(targetFileName, ext);
+          newFileName = `${name}_${counter}${ext}`;
+          newFilePath = path.join(targetDirPath, newFileName);
+          counter++;
+        } while (fs.existsSync(newFilePath));
+
+        console.log(chalk.yellow(`  重命名冲突文件: ${targetFileName} -> ${newFileName}`));
+        fs.copySync(sourcePath, newFilePath);
+      } else {
+        // 正常拷贝
+        fs.copySync(sourcePath, actualTargetPath);
+      }
+    }
+  }
+}
+
+// 判断是否要跳过文件
+function shouldSkipFile(filename) {
+  const ignoredItems = ["node_modules", ".git", ".DS_Store", "Thumbs.db", ".vscode", ".idea", "dist", "build", ".env.local", ".npmrc", ".yarnrc"];
+
+  if (ignoredItems.includes(filename)) {
+    return true;
+  }
+
+  // 跳过临时文件
+  if (filename.endsWith(".log") || filename.endsWith(".tmp") || filename.startsWith("~$") || filename === ".tmp") {
+    return true;
+  }
+
+  return false;
+}
+
+// 替换文件中的占位符（增强版本）
+async function replacePlaceholders(projectDir, projectName, skipFiles = new Set()) {
+  // 递归处理目录
+  const processDir = async (dir) => {
+    if (!fs.existsSync(dir)) return;
+
+    const items = fs.readdirSync(dir);
+
+    for (const item of items) {
+      const itemPath = path.join(dir, item);
+
+      // 跳过冲突文件
+      if (skipFiles.has(itemPath)) {
+        continue;
+      }
+
+      const stats = fs.statSync(itemPath);
+
+      if (stats.isDirectory()) {
+        // 跳过不需要的目录
+        if (["node_modules", ".git", "dist", "build"].includes(item)) {
+          continue;
+        }
+        await processDir(itemPath);
+      } else if (stats.isFile()) {
+        await replaceInFile(itemPath, projectName);
+      }
+    }
+  };
+
+  await processDir(projectDir);
+}
+
+// 在单个文件中替换占位符
+async function replaceInFile(filePath, projectName) {
+  // 只处理文本文件
+  const textExtensions = [".js", ".ts", ".jsx", ".tsx", ".vue", ".md", ".txt", ".json", ".yml", ".yaml", ".xml", ".html", ".htm", ".css", ".scss", ".less", ".php", ".py", ".java", ".c", ".cpp", ".go", ".rb", ".rs"];
+
+  const ext = path.extname(filePath).toLowerCase();
+  if (!textExtensions.includes(ext)) {
+    return;
+  }
+
+  try {
+    let content = fs.readFileSync(filePath, "utf8");
+    let modified = false;
+
+    // 常见的占位符映射
+    const placeholders = {
+      "{{project-name}}": projectName,
+      "{{project_name}}": projectName.replace(/-/g, "_"),
+      "{{projectName}}": projectName.replace(/-(\w)/g, (_, c) => c.toUpperCase()),
+      "{{ProjectName}}": projectName.replace(/-(\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase()),
+      "{{PROJECT_NAME}}": projectName.toUpperCase().replace(/-/g, "_"),
+      "{{name}}": projectName,
+      "{{NAME}}": projectName.toUpperCase(),
+    };
+
+    // 替换所有占位符
+    for (const [placeholder, value] of Object.entries(placeholders)) {
+      if (content.includes(placeholder)) {
+        content = content.replace(new RegExp(placeholder, "g"), value);
+        modified = true;
+      }
+    }
+
+    // 特别处理 package.json
+    if (path.basename(filePath) === "package.json") {
+      try {
+        const packageJson = JSON.parse(content);
+        let pkgModified = false;
+
+        // 替换各种可能的占位符格式
+        const pkgFields = ["name", "description", "version", "author"];
+        for (const field of pkgFields) {
+          if (packageJson[field] && typeof packageJson[field] === "string") {
+            for (const [placeholder, value] of Object.entries(placeholders)) {
+              if (packageJson[field].includes(placeholder)) {
+                packageJson[field] = packageJson[field].replace(new RegExp(placeholder, "g"), field === "name" ? projectName : value);
+                pkgModified = true;
+              }
+            }
+          }
+        }
+
+        if (pkgModified) {
+          content = JSON.stringify(packageJson, null, 2);
+          modified = true;
+        }
+      } catch (e) {
+        // JSON 解析失败，跳过
+      }
+    }
+
+    if (modified) {
+      fs.writeFileSync(filePath, content);
+    }
+  } catch (error) {
+    // 文件读取失败，跳过
+  }
+}
+
+// 显示成功信息
+function showSuccessInfo(targetDir, projectName, templateName, projectType) {
+  console.log(chalk.green("\n🎉 项目创建成功！"));
+  console.log(chalk.cyan("══════════════════════════════════════\n"));
+
+  console.log(chalk.white.bold("📁 项目信息:"));
+  console.log(chalk.cyan(`  项目名称: ${projectName}`));
+  console.log(chalk.cyan(`  项目路径: ${targetDir}`));
+  console.log(chalk.cyan(`  项目类型: ${projectType === "application" ? "应用程序" : "主题"}`));
+  console.log(chalk.cyan(`  使用模板: ${templateName}`));
+
+  const relativePath = path.relative(process.cwd(), targetDir);
+
+  console.log(chalk.white.bold("\n🚀 下一步操作:"));
+  console.log(chalk.cyan(`  cd ${relativePath}`));
+
+  // 检查是否有 package.json 来推荐安装依赖
+  const packageJsonPath = path.join(targetDir, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    console.log(chalk.cyan("  npm install  # 安装依赖"));
+
+    // 根据常见的启动脚本推荐命令
+    try {
+      const packageJson = fs.readJsonSync(packageJsonPath);
+      if (packageJson.scripts) {
+        if (packageJson.scripts.dev) {
+          console.log(chalk.cyan(`  npm run dev   # 启动开发服务器`));
+        } else if (packageJson.scripts.start) {
+          console.log(chalk.cyan(`  npm start     # 启动项目`));
+        }
+      }
+    } catch (error) {
+      // 解析失败，使用默认推荐
+      console.log(chalk.cyan(`  npm start     # 启动项目`));
+    }
+  }
+
+  console.log(chalk.cyan("\n📚 查看文档:"));
+  console.log(chalk.cyan(`  查看 ${projectName}/README.md 获取详细说明`));
+
+  console.log(chalk.yellow("\n💡 提示:"));
+  console.log(chalk.cyan("  如果存在文件冲突，请检查是否有文件被重命名"));
+
+  console.log(chalk.green("\n✨ 开始您的开发之旅吧！\n"));
+}
+
+module.exports = { program };