ai-worktool 1.0.7

package/dist/tools/package.js

@@ -0,0 +1,376 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProject = initProject;
+exports.installDependencies = installDependencies;
+exports.addScript = addScript;
+exports.runTest = runTest;
+exports.setupTestEnvironment = setupTestEnvironment;
+const child_process_1 = require("child_process");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+// 将exec转换为返回Promise的函数
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * 检查指定路径下是否存在package.json文件
+ *
+ * @param projectPath 项目路径
+ * @returns Promise<boolean> 存在返回true，否则返回false
+ */
+async function hasPackageJson(projectPath) {
+    try {
+        await promises_1.default.access(path_1.default.join(projectPath, 'package.json'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 获取包管理器对应的命令字符串
+ *
+ * @param manager 包管理器类型，默认为'yarn'
+ * @returns string 包管理器命令（如'yarn'或'npm'）
+ */
+function getPackageManagerCommand(manager = 'yarn') {
+    return manager;
+}
+/**
+ * 生成安装依赖的命令字符串
+ *
+ * @param dependencies 依赖包列表
+ * @param isDev 是否为开发依赖（devDependencies）
+ * @param manager 包管理器类型，默认为'yarn'
+ * @returns string 安装依赖的命令字符串，依赖为空时返回空字符串
+ */
+function getInstallCommand(dependencies, isDev, manager = 'yarn') {
+    if (!dependencies.length) {
+        return '';
+    }
+    if (manager === 'yarn') {
+        return isDev ? `yarn add ${dependencies.join(' ')} --dev` : `yarn add ${dependencies.join(' ')}`;
+    }
+    else {
+        return isDev ? `npm install --save-dev ${dependencies.join(' ')}` : `npm install --save ${dependencies.join(' ')}`;
+    }
+}
+/**
+ * 生成运行npm/yarn脚本的命令字符串
+ *
+ * @param scriptName 脚本名称（如'test'、'build'）
+ * @param args 传递给脚本的参数列表，默认为空数组
+ * @param manager 包管理器类型，默认为'yarn'
+ * @returns string 运行脚本的命令字符串
+ */
+function getRunScriptCommand(scriptName, args = [], manager = 'yarn') {
+    if (manager === 'yarn') {
+        return `yarn ${scriptName} ${args.join(' ')}`.trim();
+    }
+    else {
+        return `npm run ${scriptName} -- ${args.join(' ')}`.trim();
+    }
+}
+/**
+ * 初始化项目（生成package.json文件）
+ *
+ * @export
+ * @param projectPath 项目路径
+ * @param manager 包管理器类型，默认为'yarn'
+ * @returns Promise<void> 初始化成功时resolve，失败时reject
+ * @description 静默执行（无弹窗），若package.json已存在则跳过初始化
+ */
+async function initProject(projectPath, manager = 'yarn') {
+    try {
+        projectPath = projectPath;
+        const resolvedPath = path_1.default.resolve(projectPath);
+        if (!(await hasPackageJson(resolvedPath))) {
+            const cmd = getPackageManagerCommand(manager);
+            const initCmd = cmd === 'yarn' ? 'yarn init -y' : 'npm init -y';
+            // 静默执行：不显示弹窗，不输出到控制台
+            await executeCommand(resolvedPath, initCmd, '初始化项目');
+            console.log(`成功使用${cmd}初始化项目`);
+        }
+        else {
+            console.log('package.json已存在，跳过初始化');
+            // 检查node_modules目录是否存在（判断是否已安装依赖）
+            const nodeModulesPath = path_1.default.join(resolvedPath, 'node_modules');
+            try {
+                await promises_1.default.access(nodeModulesPath);
+                console.log('依赖已安装，无需操作');
+            }
+            catch {
+                console.log('检测到未安装依赖，开始安装...');
+                // 安装所有依赖（生产+开发）
+                const installCmd = manager === 'yarn' ? 'yarn install' : 'npm install';
+                await executeCommand(resolvedPath, installCmd, '安装项目依赖');
+                console.log('依赖安装完成');
+            }
+        }
+    }
+    catch (error) {
+        console.error('初始化项目失败:', error);
+        throw error;
+    }
+}
+/**
+ * 安装项目依赖
+ *
+ * @export
+ * @param projectPath 项目路径
+ * @param dependencies 依赖包列表（数组或逗号分隔的字符串）
+ * @param isDev 是否安装为开发依赖，默认为false
+ * @param manager 包管理器类型，默认为'yarn'
+ * @returns Promise<void> 安装成功时resolve，失败时reject
+ * @description 静默执行（无弹窗），支持批量安装依赖
+ */
+async function installDependencies(projectPath, dependencies, isDev = false, manager = 'yarn') {
+    try {
+        // 处理字符串类型的依赖（逗号分隔）
+        if (typeof dependencies === 'string') {
+            dependencies = dependencies.split(',').map((dep) => dep.trim());
+        }
+        const resolvedPath = path_1.default.resolve(projectPath);
+        const installCmd = getInstallCommand(dependencies, isDev, manager);
+        if (!installCmd) {
+            console.log('没有需要安装的依赖');
+            return;
+        }
+        console.log(`正在安装依赖: ${dependencies.join(', ')}`);
+        // 静默执行：不显示弹窗，不输出安装过程
+        await executeCommand(resolvedPath, installCmd, '正在安装依赖');
+        console.log('依赖安装完成');
+    }
+    catch (error) {
+        console.error('安装依赖失败:', error);
+        throw error;
+    }
+}
+/**
+ * 向package.json的scripts字段添加自定义脚本
+ *
+ * @export
+ * @param projectPath 项目路径
+ * @param scriptName 脚本名称（如'start'、'build'）
+ * @param scriptCommand 脚本执行的命令（如'node index.js'）
+ * @returns Promise<void> 添加成功时resolve，失败时reject
+ */
+async function addScript(projectPath, scriptName, scriptCommand) {
+    try {
+        const resolvedPath = path_1.default.resolve(projectPath);
+        const pkgPath = path_1.default.join(resolvedPath, 'package.json');
+        const pkgContent = await promises_1.default.readFile(pkgPath, 'utf8');
+        const pkg = JSON.parse(pkgContent);
+        pkg.scripts = pkg.scripts || {};
+        pkg.scripts[scriptName] = scriptCommand;
+        await promises_1.default.writeFile(pkgPath, JSON.stringify(pkg, null, 2));
+        console.log(`已添加脚本: ${scriptName}="${scriptCommand}"`);
+    }
+    catch (error) {
+        console.error('添加脚本失败:', error);
+        throw error;
+    }
+}
+/**
+ * 运行项目中的测试脚本（package.json中定义的'test'脚本）
+ *
+ * @export
+ * @param projectPath 项目路径
+ * @param args 传递给测试脚本的参数列表，默认为空数组
+ * @param manager 包管理器类型，默认为'yarn'
+ * @returns Promise<void> 测试成功时resolve，失败时reject
+ * @description 静默执行（无弹窗），通过Promise返回测试结果
+ */
+async function runTest(projectPath, args = [], manager = 'yarn') {
+    try {
+        const resolvedPath = path_1.default.resolve(projectPath);
+        const runCmd = getRunScriptCommand('test', args, manager);
+        const [cmd, ...cmdArgs] = runCmd.split(' ').filter(Boolean);
+        console.log(`正在运行测试: ${runCmd}`);
+        // 静默执行测试（无弹窗）
+        await executeCommand(resolvedPath, `${cmd} ${cmdArgs.join(' ')}`, '运行测试');
+    }
+    catch (error) {
+        console.error('启动测试失败:', error);
+        throw error;
+    }
+}
+/**
+ * 验证输入参数是否有效
+ * @param packageManager 包管理器
+ * @param devLanguage 开发语言
+ * @param testFramework 测试框架
+ * @throws {Error} 当参数无效时抛出错误
+ */
+function validateParameters(packageManager, devLanguage, testFramework) {
+    const validPackageManagers = ['npm', 'yarn', 'pnpm'];
+    const validLanguages = ['typescript', 'javascript'];
+    const validTestFrameworks = ['jest', 'mocha', 'vitest'];
+    if (!validPackageManagers.includes(packageManager) || !packageManager || packageManager === 'unknown') {
+        throw new Error(`无效的包管理器: ${packageManager}。有效值: ${validPackageManagers.join(', ')}`);
+    }
+    if (!validLanguages.includes(devLanguage) || !devLanguage || devLanguage === 'unknown') {
+        throw new Error(`无效的开发语言: ${devLanguage}。有效值: ${validLanguages.join(', ')}`);
+    }
+    if (!validTestFrameworks.includes(testFramework) || !testFramework || testFramework === 'unknown') {
+        throw new Error(`无效的测试框架: ${testFramework}。有效值: ${validTestFrameworks.join(', ')}`);
+    }
+}
+/**
+ * 执行命令并输出结果
+ * @param command 要执行的命令
+ * @param description 命令描述，用于日志输出
+ */
+async function executeCommand(resolvedPath, command, description) {
+    console.log(`正在${description}...`);
+    try {
+        const { stdout } = await execAsync(command, {
+            cwd: resolvedPath,
+            windowsHide: true
+            // stdio: 'ignore'
+        });
+        if (stdout) {
+            console.log(stdout);
+        }
+        console.log(`${description}完成`);
+    }
+    catch (error) {
+        console.error(`执行命令失败: ${command}`);
+        throw error;
+    }
+}
+/**
+ * 检查依赖是否已安装
+ * @param packageName 包名
+ * @param isDev 是否是开发依赖
+ * @returns 是否已安装
+ */
+async function checkDependency(projectRoot, packageName, isDev = false) {
+    try {
+        const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+        // 异步检查文件是否存在
+        try {
+            await promises_1.default.access(packageJsonPath);
+        }
+        catch {
+            return false;
+        }
+        // 异步读取并解析package.json
+        const packageJsonContent = await promises_1.default.readFile(packageJsonPath, 'utf8');
+        const packageJson = JSON.parse(packageJsonContent);
+        const dependencies = isDev ? packageJson.devDependencies : packageJson.dependencies;
+        return dependencies && typeof dependencies[packageName] === 'string';
+    }
+    catch (error) {
+        console.error(`检查${packageName}时出错:`, error);
+        return false;
+    }
+}
+/**
+ * 检查并搭建测试环境
+ * @param options 配置选项
+ * @param options.packageManager 包管理器 (npm, yarn, pnpm)
+ * @param options.devLanguage 开发语言 (typescript, javascript)
+ * @param options.testFramework 测试框架 (jest, mocha, vitest)
+ * @returns 是否成功搭建测试环境
+ */
+async function setupTestEnvironment(projectRoot, packageManager, devLanguage, testFramework) {
+    // 验证参数
+    validateParameters(packageManager, devLanguage, testFramework);
+    const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+    // 异步检查并初始化package.json
+    try {
+        await promises_1.default.access(packageJsonPath);
+    }
+    catch {
+        console.log('未找到package.json，初始化项目...');
+        const initCommand = packageManager === 'yarn' ? 'yarn init -y' : `${packageManager} init -y`;
+        await executeCommand(projectRoot, initCommand, '初始化项目');
+    }
+    // 如果是TypeScript项目，检查并安装TypeScript
+    if (devLanguage === 'typescript') {
+        console.log('检查TypeScript是否安装...');
+        const hasTypeScript = await checkDependency(projectRoot, 'typescript', true);
+        if (!hasTypeScript) {
+            const installCmd = getInstallCommand(['typescript', '@types/node'], true, packageManager);
+            await executeCommand(projectRoot, installCmd, '安装TypeScript及类型定义');
+            // 异步检查并创建tsconfig.json
+            const tsconfigPath = path_1.default.join(projectRoot, 'tsconfig.json');
+            try {
+                await promises_1.default.access(tsconfigPath);
+            }
+            catch {
+                await executeCommand(projectRoot, 'npx tsc --init', '创建tsconfig.json');
+            }
+        }
+    }
+    // 检查并安装测试框架
+    console.log(`检查${testFramework}是否安装...`);
+    const hasTestFramework = await checkDependency(projectRoot, testFramework, true);
+    const hasTestTypes = devLanguage === 'typescript' ? await checkDependency(projectRoot, `@types/${testFramework}`, true) : true;
+    const packagesToInstall = [];
+    if (!hasTestFramework) {
+        packagesToInstall.push(testFramework);
+    }
+    if (devLanguage === 'typescript' && !hasTestTypes) {
+        packagesToInstall.push(`@types/${testFramework}`);
+    }
+    // 框架特定的依赖
+    if (testFramework === 'jest' && devLanguage === 'typescript' && !hasTestFramework) {
+        if (await checkDependency(projectRoot, 'ts-jest', true)) {
+            packagesToInstall.push('ts-jest');
+        }
+        if (await checkDependency(projectRoot, '@types/jest', true)) {
+            packagesToInstall.push('ts-jest', '@types/jest');
+        }
+    }
+    if (testFramework === 'mocha' && !hasTestFramework) {
+        if (await checkDependency(projectRoot, 'chai', true)) {
+            packagesToInstall.push('chai');
+        } // 通常与mocha一起使用的断言库
+        if (devLanguage === 'typescript') {
+            if (await checkDependency(projectRoot, '@types/chai', true)) {
+                packagesToInstall.push('@types/chai');
+            }
+            if (await checkDependency(projectRoot, 'ts-node', true)) {
+                packagesToInstall.push('ts-node');
+            }
+        }
+    }
+    if (packagesToInstall.length > 0) {
+        const installCmd = getInstallCommand(packagesToInstall, true, packageManager);
+        await executeCommand(projectRoot, installCmd, `安装${testFramework}及相关依赖`);
+        // 框架特定的配置
+        let exists = false;
+        try {
+            await promises_1.default.access(path_1.default.join(projectRoot, 'jest.config.js'));
+            exists = true;
+        }
+        catch { }
+        if (testFramework === 'jest' && !exists) {
+            await executeCommand(projectRoot, 'npx ts-jest config:init', '配置Jest TypeScript支持');
+        }
+        console.log('✅ 测试环境搭建完成！');
+    }
+    // 检查并添加test脚本
+    console.log('检查测试脚本是否配置...');
+    // 异步读取package.json
+    const packageJsonContent = await promises_1.default.readFile(packageJsonPath, 'utf8');
+    const packageJson = JSON.parse(packageJsonContent);
+    packageJson.scripts = packageJson.scripts || {};
+    if (!packageJson.scripts.test) {
+        console.log('添加测试脚本到package.json...');
+        let testCommand = testFramework;
+        if (testFramework === 'mocha' && devLanguage === 'typescript') {
+            testCommand = 'mocha --require ts-node/register "test/**/*.ts"';
+        }
+        packageJson.scripts.test = testCommand;
+        // 异步写入package.json
+        await promises_1.default.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log(`可以使用 ${packageManager} test 命令运行测试`);
+    }
+    return true;
+}
+//# sourceMappingURL=package.js.map