@blocklet/component-studio-cli 0.4.134

package/dist/utils/helper.js

@@ -0,0 +1,479 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { execSync } from 'child_process';
+import { glob } from 'glob';
+import inquirer from 'inquirer';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { cp } from 'node:fs/promises';
+import { readdir, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join, resolve, dirname, basename, relative } from 'node:path';
+import ora from 'ora';
+import os from 'os';
+const workspaceVersion = '0.1.0';
+const METADATA_FILE_NAME = '@metadata.json';
+// 获取CLI内置的workspace模板路径
+export function getWorkspaceTemplatePath() {
+    return join(__dirname, '../../templates/workspace');
+}
+// 获取用户电脑的workspace路径
+export function getWorkspacePath() {
+    const homeDir = os.homedir();
+    const workspaceHash = workspaceVersion;
+    const workspaceDir = join(homeDir, `.component-studio`, workspaceHash);
+    return workspaceDir;
+}
+// 获取当前项目路径
+export function getProjectPath() {
+    const projectPath = resolve(process.cwd());
+    return projectPath;
+}
+/**
+ * 复制模板文件，但排除某些特定文件
+ * @param sourcePath - 源模板路径
+ * @param targetPath - 目标项目路径
+ */
+export async function copyTemplateFilesExcept(sourcePath, targetPath) {
+    // 需要排除的文件
+    const excludeFiles = ['@template.json', 'package.json'];
+    try {
+        // 读取源目录中的所有文件和目录
+        const entries = await readdir(sourcePath, { withFileTypes: true });
+        for (const entry of entries) {
+            const sourceName = join(sourcePath, entry.name);
+            const targetName = join(targetPath, entry.name);
+            // 如果是目录，递归复制
+            if (entry.isDirectory()) {
+                await mkdir(targetName, { recursive: true });
+                await copyTemplateFilesExcept(sourceName, targetName);
+            }
+            // 如果是文件且不在排除列表中，则复制
+            else if (!excludeFiles.includes(entry.name)) {
+                await cp(sourceName, targetName);
+            }
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to copy template files: ${error.message}`);
+    }
+}
+/**
+ * 合并基础 package.json 和模板的 package.json
+ * @param basePath - 基础包路径
+ * @param templatePath - 模板路径
+ */
+export async function mergePackageJson(basePath, templatePath) {
+    const excludeKeys = ['name', 'version'];
+    const basePackagePath = join(basePath, 'package.json');
+    const templatePackagePath = join(templatePath, 'package.json');
+    if (!existsSync(templatePackagePath)) {
+        return; // 没有模板 package.json，不需要合并
+    }
+    try {
+        // 读取基础 package.json
+        const basePackage = JSON.parse(await readFile(basePackagePath, 'utf8'));
+        // 读取模板 package.json
+        const templatePackage = JSON.parse(await readFile(templatePackagePath, 'utf8'));
+        // 合并包，保留基础包的 name 和 version
+        const name = basePackage.name;
+        const version = basePackage.version;
+        const mergedPackage = {
+            name, // 保留原名称
+            version, // 保留原版本
+            // 合并其余属性，但不覆盖name和version
+            ...Object.fromEntries(Object.entries(templatePackage).filter(([key]) => !excludeKeys.includes(key))),
+            // 合并依赖
+            dependencies: { ...basePackage.dependencies, ...templatePackage.dependencies },
+            devDependencies: { ...basePackage.devDependencies, ...templatePackage.devDependencies },
+            scripts: { ...basePackage.scripts, ...templatePackage.scripts },
+        };
+        // 写回合并后的 package.json
+        await writeFile(basePackagePath, JSON.stringify(mergedPackage, null, 2));
+    }
+    catch (error) {
+        console.warn(chalk.yellow('Failed to merge package.json files:', error));
+    }
+}
+/**
+ * 在指定目录安装依赖
+ * @param dirs - 需要安装依赖的目录对象，key为目录描述，value为目录路径
+ * @returns 安装结果
+ */
+export async function installDependencies(dirs, operation = 'install') {
+    const baseDepsText = operation === 'update' ? 'Updating latest dependencies...' : 'Installing latest dependencies...';
+    const depsSpinner = ora({ text: baseDepsText, color: 'blue' }).start();
+    try {
+        const installPromises = Object.entries(dirs).map(([dirType, dirPath]) => {
+            return new Promise((resolve, reject) => {
+                const process = spawn('pnpm', ['update:deps'], {
+                    cwd: dirPath,
+                    // stdio: 'inherit',
+                });
+                process.on('close', (code) => {
+                    if (code === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`${dirType} dependencies install failed with code ${code}`));
+                    }
+                });
+            });
+        });
+        // 制作一个假进度条，每秒增加 1%
+        let progress = 0;
+        let progressStep = 1;
+        const interval = setInterval(() => {
+            if (progress < 99.9) {
+                progress = parseFloat((progress + progressStep).toFixed(1));
+                depsSpinner.text = `${baseDepsText} ${progress}%`;
+                if (progress >= 70) {
+                    progressStep = 0.3;
+                }
+                if (progress >= 90) {
+                    progressStep = 0.1;
+                }
+            }
+        }, 1000);
+        await Promise.all(installPromises);
+        clearInterval(interval);
+        depsSpinner.succeed(chalk.green(operation === 'update'
+            ? 'Update latest dependencies successfully!'
+            : 'Install latest dependencies successfully!'));
+        return true;
+    }
+    catch (error) {
+        depsSpinner.fail(chalk.red('Failed to install dependencies'));
+        console.error(error);
+        return false;
+    }
+}
+/**
+ * 从模板目录读取所有可用模板
+ * @param templatesDir - 模板目录路径，默认为 templates/init
+ * @returns 可用模板数组
+ */
+export function loadTemplates(templatesDir) {
+    // 如果没有提供路径，使用默认路径
+    const templatesDirPath = templatesDir;
+    if (!existsSync(templatesDirPath)) {
+        console.warn(chalk.yellow(`Templates directory not found: ${templatesDirPath}`));
+        return [];
+    }
+    try {
+        const templateFolders = readdirSync(templatesDirPath, { withFileTypes: true })
+            .filter((dirent) => dirent.isDirectory())
+            .map((dirent) => dirent.name);
+        return templateFolders.flatMap((folder) => {
+            const folderPath = join(templatesDirPath, folder);
+            // 检查是否是直接包含@template.json的目录
+            const metadataPath = join(folderPath, '@template.json');
+            if (existsSync(metadataPath)) {
+                try {
+                    const metadata = JSON.parse(readFileSync(metadataPath, 'utf8'));
+                    return [
+                        {
+                            key: folder,
+                            name: metadata.name || folder,
+                            description: metadata.description || `The description of this template is empty`,
+                        },
+                    ];
+                }
+                catch (error) {
+                    console.warn(chalk.yellow(`Failed to parse metadata for template "${folder}"`));
+                }
+            }
+            // 检查子目录
+            const subFolders = readdirSync(folderPath, { withFileTypes: true })
+                .filter((dirent) => dirent.isDirectory())
+                .map((dirent) => dirent.name);
+            return subFolders.map((subFolder) => {
+                const subFolderPath = join(folderPath, subFolder);
+                const subMetadataPath = join(subFolderPath, '@template.json');
+                if (existsSync(subMetadataPath)) {
+                    try {
+                        const metadata = JSON.parse(readFileSync(subMetadataPath, 'utf8'));
+                        return {
+                            key: `${folder}/${subFolder}`,
+                            name: metadata.name || subFolder,
+                            description: metadata.description || `The description of this template is empty`,
+                        };
+                    }
+                    catch (error) {
+                        console.warn(chalk.yellow(`Failed to parse metadata for template "${folder}/${subFolder}"`));
+                    }
+                }
+                // 默认元数据
+                return {
+                    key: `${folder}/${subFolder}`,
+                    name: subFolder,
+                    description: `The description of this template is empty`,
+                };
+            });
+        });
+    }
+    catch (error) {
+        console.error(chalk.red('Error loading templates:'), error);
+        return [];
+    }
+}
+/**
+ * 交互式选择模板，支持模板分组
+ * @param templates - 模板数组
+ * @param defaultTemplate - 可选的默认模板键名
+ * @returns Promise<string> 选择的模板键名
+ */
+export async function selectTemplate(templates, defaultTemplate, groupByDir) {
+    // 构建模板选择列表，按目录分组
+    const templateGroups = {};
+    templates.forEach((template) => {
+        // 使用第一级目录作为分组
+        const groupName = groupByDir ? template.key.split('/')[0] || 'other' : 'ungrouped';
+        if (!templateGroups[groupName]) {
+            templateGroups[groupName] = [];
+        }
+        templateGroups[groupName].push(template);
+    });
+    // 构建带分组的选项
+    const choices = [];
+    // 为每个分组添加标题和选项
+    Object.entries(templateGroups).forEach(([group, groupTemplates]) => {
+        if (groupByDir) {
+            // 添加分组标题
+            choices.push(new inquirer.Separator(`====== ${group.toUpperCase()} =====`));
+        }
+        // 添加该分组下的模板
+        groupTemplates.forEach((t) => {
+            choices.push({
+                name: `${t.name}${t.description ? ` - ${t.description}` : ''}`,
+                value: t.key,
+            });
+        });
+    });
+    // 确保有选择选项
+    const validChoices = choices.filter((c) => !c.disabled);
+    if (validChoices.length === 0) {
+        console.log(chalk.red('No valid templates found. Please check your installation.'));
+        process.exit(1);
+    }
+    // 默认选项：优先使用指定的默认模板，然后是basic模板，最后是第一个有效选项
+    let defaultChoice = defaultTemplate;
+    if (!defaultChoice) {
+        const basicTemplate = templates.find((t) => t.name === 'basic');
+        if (basicTemplate) {
+            defaultChoice = basicTemplate.key;
+        }
+        else {
+            // 找到第一个非分隔符的有效选项
+            const firstValid = choices.find((c) => !c.disabled);
+            defaultChoice = firstValid ? firstValid.value : '';
+        }
+    }
+    const { template } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'template',
+            message: 'Select a template:',
+            choices,
+            default: defaultChoice,
+        },
+    ]);
+    return template;
+}
+/**
+ * 验证所选模板是否存在
+ * @param templateKey - 模板键名
+ * @param templates - 模板数组
+ * @returns 选中的模板或null
+ */
+export function validateTemplate(templateKey, templates) {
+    const selectedTemplate = templates.find((t) => t.key === templateKey);
+    if (!selectedTemplate) {
+        console.log(chalk.red(`Template "${templateKey}" is not supported.`));
+        console.log(chalk.yellow('Available templates:'));
+        templates.forEach((t) => {
+            console.log(`  - ${chalk.cyan(t.name)}${t.description ? `: ${t.description}` : ''}`);
+        });
+        return null;
+    }
+    return selectedTemplate;
+}
+/**
+ * 获取模板路径
+ * @param templateKey - 模板键名
+ * @param templatesBaseDir - 模板基础目录，默认为 templates/init
+ * @returns 模板完整路径
+ */
+export function getTemplatePath(templateKey, templatesBaseDir) {
+    return join(templatesBaseDir, templateKey);
+}
+/**
+ * 在文件中批量替换占位符
+ * @param filePath - 文件路径
+ * @param replacements - 替换对象，键为占位符，值为替换内容
+ */
+export async function replaceInFile(filePath, replacements) {
+    try {
+        // 读取文件内容
+        let content = await readFile(filePath, 'utf8');
+        // 执行所有替换
+        for (const [placeholder, value] of Object.entries(replacements)) {
+            const regex = new RegExp(placeholder, 'g');
+            content = content.replace(regex, value);
+        }
+        // 写回文件
+        await writeFile(filePath, content, 'utf8');
+    }
+    catch (error) {
+        console.error(chalk.red(`Error replacing placeholders in ${filePath}:`), error);
+        throw error;
+    }
+}
+/**
+ * 在目录中递归替换所有文件中的占位符
+ * @param dirPath - 目录路径
+ * @param replacements - 替换对象，键为占位符，值为替换内容
+ */
+export async function replaceInDirectory(dirPath, replacements) {
+    try {
+        // 读取目录内容
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        // 处理每个条目
+        for (const entry of entries) {
+            const fullPath = join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                // 如果是目录，递归处理
+                await replaceInDirectory(fullPath, replacements);
+            }
+            else if (entry.isFile()) {
+                // 如果是文件，执行替换
+                await replaceInFile(fullPath, replacements);
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error replacing placeholders in directory ${dirPath}:`), error);
+        throw error;
+    }
+}
+/**
+ * 查找最接近指定目录的包含@metadata.json的目录
+ * @param startDir - 起始目录
+ * @returns 找到的最近目录或null
+ */
+export async function findClosestMetadataDir(startDir) {
+    try {
+        // 从startDir开始向上查找所有包含@metadata.json的目录
+        const metadataFiles = await glob(`**/${METADATA_FILE_NAME}`, {
+            cwd: startDir,
+            absolute: true,
+        });
+        // 按照目录层级深度排序，找到最近的目录
+        if (metadataFiles.length > 0) {
+            // 按路径长度排序，最短的路径通常是最接近startDir的
+            metadataFiles.sort((a, b) => a.length - b.length);
+            const firstFile = metadataFiles[0];
+            if (firstFile) {
+                const closestMetadataDir = dirname(firstFile);
+                return dirname(closestMetadataDir);
+            }
+        }
+    }
+    catch (error) {
+        console.warn(chalk.yellow('Error searching for metadata files:'), error);
+    }
+    return null;
+}
+/**
+ * 检查目标目录是否存在，如存在则询问是否覆盖
+ * @param targetDir - 目标目录路径
+ * @param itemType - 项目类型名称 (如 'component', 'tool')
+ * @param targetBaseDir - 基础目录路径（用于显示相对路径）
+ * @returns 是否可以继续操作（不存在或用户同意覆盖）
+ */
+export async function checkTargetDirectoryExists(targetDir, targetBaseDir) {
+    const projectPath = getProjectPath();
+    // 检查目标目录是否已存在
+    if (existsSync(targetDir)) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `The "${basename(targetDir)}" already exists in ${relative(projectPath, targetBaseDir) || projectPath}. Do you want to overwrite it?`,
+                default: false,
+            },
+        ]);
+        if (!answers.overwrite) {
+            console.log(chalk.yellow('Operation cancelled.'));
+            return false;
+        }
+    }
+    return true;
+}
+// 检查包是否已安装
+export function isPackageInstalled(packageName, projectPath) {
+    try {
+        // 检查node_modules中是否存在该包
+        return existsSync(join(projectPath, 'node_modules', packageName));
+    }
+    catch (error) {
+        return false;
+    }
+}
+// 检查文件中是否引用了特定包
+export function checkPackageReference(filePath, packageName) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        // 查找导入语句 (支持各种导入格式)
+        const importRegex = new RegExp(`(import|from)\\s+['"]${packageName.replace(/\//g, '\\/')}(\\/[^'"]+)?['"]`, 'g');
+        return importRegex.test(content);
+    }
+    catch (error) {
+        return false;
+    }
+}
+// 安装缺失的包
+export function installMissingPackage(packageName, projectPath) {
+    try {
+        console.log(chalk.yellow(`\nDetected ${packageName} dependency. Installing...`));
+        // 尝试使用pnpm安装
+        execSync(`cd "${projectPath}" && pnpm add ${packageName}`, { stdio: 'inherit' });
+        return true;
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to install ${packageName}: ${error.message}`));
+        return false;
+    }
+}
+/**
+ * 检查系统中是否存在指定命令
+ * @param command - 要检查的命令名称
+ * @returns 命令是否存在
+ */
+export function isCommandAvailable(command) {
+    try {
+        const isWindows = process.platform === 'win32';
+        const whichCommand = isWindows ? 'where' : 'which';
+        execSync(`${whichCommand} ${command}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * 安装全局NPM包
+ * @param packageName - 要安装的包名
+ * @returns 安装是否成功
+ */
+export async function installGlobalPackage(packageName) {
+    const spinner = ora(`Installing ${packageName} globally...`).start();
+    try {
+        execSync(`npm install -g ${packageName}`, { stdio: 'ignore' });
+        spinner.succeed(`${packageName} installed successfully!`);
+        return true;
+    }
+    catch (error) {
+        spinner.fail(`Failed to install ${packageName}`);
+        console.error(error);
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@blocklet/component-studio-cli",
+  "version": "0.4.134",
+  "description": "CLI for Component Studio",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Arcblock <blocklet@arcblock.io> https://github.com/blocklet",
+  "homepage": "https://github.com/blocklet/pages-kit#readme",
+  "license": "ISC",
+  "bin": {
+    "component-studio": "dist/cli.js"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "workspace",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "templates"
+  ],
+  "exports": {
+    "./*": "./dist/*"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*"
+      ]
+    }
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "fs-extra": "^11.2.0",
+    "glob": "^11.0.1",
+    "gradient-string": "^3.0.0",
+    "inquirer": "^12.5.2",
+    "ora": "^8.2.0",
+    "pretty-error": "^4.0.0",
+    "tar": "^7.4.3",
+    "@blocklet/pages-kit-block-studio": "^0.4.134"
+  },
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/node": "^22.14.1",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "lint": "tsc --noEmit",
+    "build": "pnpm run clean && tsc --build tsconfig.build.json",
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "test": "node --test"
+  }
+}