ai-worktool 1.0.0

package/dist/tools/jest.js

@@ -0,0 +1,484 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJestConfigFile = createJestConfigFile;
+exports.runJestTests = runJestTests;
+exports.getFailedTests = getFailedTests;
+exports.parseLcovForUncoveredLines = parseLcovForUncoveredLines;
+exports.readCoverageSummary = readCoverageSummary;
+exports.generateUncoveredLinesReport = generateUncoveredLinesReport;
+exports.getFailedTestSummaries = getFailedTestSummaries;
+exports.findTestErrorDetails = findTestErrorDetails;
+exports.clearJsonReportCache = clearJsonReportCache;
+exports.openLcovReport = openLcovReport;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const util_1 = __importDefault(require("util"));
+// 转换exec为Promise形式，便于async/await使用
+const execAsync = util_1.default.promisify(child_process_1.exec);
+/**
+ * 创建 Jest 配置文件
+ *
+ * 该函数会在指定路径创建一个 Jest 配置文件（jest.config.js），
+ * 包含基本的测试配置选项。如果文件已存在，将不会覆盖原有文件。
+ *
+ * @param configPath 配置文件保存路径（包含文件名，如：./jest.config.js）
+ * @param options Jest 配置选项，用于自定义测试配置
+ * @returns 返回一个 Promise，当配置文件创建成功时解析为文件路径，若文件已存在则返回 null
+ * @throws 当写入文件时发生错误时抛出异常
+ */
+async function createJestConfigFile(configPath, options = {}) {
+    // 检查文件是否已存在
+    try {
+        await fs.access(configPath);
+        // 文件已存在，返回 null 表示未创建新文件
+        return null;
+    }
+    catch {
+        // 文件不存在，继续创建
+    }
+    options = typeof options === 'string' ? JSON.parse(options) : options;
+    // 合并默认配置和用户配置
+    const defaultConfig = {
+        testMatch: ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'],
+        moduleFileExtensions: ['js', 'jsx', 'ts', 'tsx', 'json', 'node'],
+        transform: {
+            '^.+\\.(ts|tsx)$': 'ts-jest',
+            '^.+\\.(js|jsx)$': 'babel-jest'
+        },
+        collectCoverage: true,
+        // 指定需要统计覆盖率的源代码路径（关键配置）
+        collectCoverageFrom: [
+            // 匹配所有源代码文件（根据项目目录结构调整）
+            'src/**/*.{js,jsx,ts,tsx}', // 例如：src 目录下所有 JS/TS 文件
+            '!src/**/*.d.ts', // 排除类型定义文件（可选）
+            '!src/mocks/**', // 排除 mock 文件（可选）
+            '!src/**/index.{js,ts}', // 排除入口文件（可选，根据需求调整）
+            '!**/node_modules/**', // 排除 node_modules
+            '!**/vendor/**' // 排除第三方依赖（如有）
+        ],
+        coverageDirectory: 'coverage',
+        coverageReporters: ['json-summary', 'lcov', 'text', 'clover'],
+        testPathIgnorePatterns: ['/node_modules/']
+    };
+    const mergedConfig = { ...defaultConfig, ...options };
+    // 生成配置文件内容
+    const configContent = `module.exports = ${JSON.stringify(mergedConfig, null, 2)};\n`;
+    // 确保目录存在
+    const dirPath = path.dirname(configPath);
+    await fs.mkdir(dirPath, { recursive: true });
+    // 写入配置文件
+    await fs.writeFile(configPath, configContent, 'utf-8');
+    return configPath;
+}
+async function getTestResultsState(projectRoot, coverageDir = 'coverage') {
+    coverageDir = coverageDir || 'coverage';
+    const testResultsPath = path.join(projectRoot, coverageDir, 'test-results.json');
+    if (await fileExists(testResultsPath)) {
+        const testResults = JSON.parse(await fs.readFile(testResultsPath, 'utf-8'));
+        if (!testResults.testResults) {
+            return null;
+        }
+        return fs.stat(testResultsPath);
+    }
+    else {
+        return null;
+    }
+}
+/**
+ * 执行 Jest 单元测试并生成覆盖率报告
+ * @param projectRoot 项目根目录
+ * @param jestConfigPath Jest 配置文件路径（可选）
+ */
+async function runJestTests(projectRoot, coverageDir = 'coverage', jestConfigPath) {
+    coverageDir = coverageDir || 'coverage';
+    if (!(await fileExists(path.join(projectRoot, 'package.json')))) {
+        throw new Error('当前目录下不存在 package.json 文件，请确保当前目录为项目根目录。');
+    }
+    return new Promise((resolve, reject) => {
+        const now = Date.now();
+        const testResultsFile = path.join(projectRoot, coverageDir, 'test-results.json');
+        const jestCommand = jestConfigPath
+            ? `npx jest --coverage --coverageReporters="json-summary" --coverageReporters="lcov" --json --outputFile="${testResultsFile}" --config ${jestConfigPath}`
+            : `npx jest --coverage --coverageReporters="json-summary" --coverageReporters="lcov" --json --outputFile="${testResultsFile}"`;
+        const childProcess = (0, child_process_1.exec)(jestCommand, {
+            cwd: projectRoot,
+            encoding: 'utf-8'
+        });
+        let stdout = '';
+        let stderr = '';
+        childProcess.stdout?.on('data', (data) => {
+            stdout += data;
+        });
+        childProcess.stderr?.on('data', (data) => {
+            stderr += data;
+        });
+        childProcess.on('close', async (code) => {
+            // 单测用例失败返回成功
+            if (code !== 0) {
+                // const error = new Error(`Jest测试失败，退出码: ${code}\n${stderr}`);
+                // console.error(`执行 Jest 测试失败: ${error.message}`);
+                const state = await getTestResultsState(projectRoot, coverageDir);
+                // 即使测试失败，仍然返回部分结果
+                resolve({
+                    testResultsFile,
+                    success: state?.mtimeMs >= now,
+                    noTestsFound: stderr.includes('No tests found, exiting with code 1'),
+                    exitCode: code,
+                    stdout,
+                    stderr
+                });
+            }
+            else {
+                resolve({
+                    testResultsFile,
+                    success: true,
+                    exitCode: code,
+                    stdout,
+                    stderr
+                });
+            }
+        });
+        childProcess.on('error', (err) => {
+            console.error(`执行 Jest 测试失败: ${err.message}`);
+            reject(err);
+        });
+    });
+}
+// 辅助函数：异步检查文件是否存在
+async function fileExists(path) {
+    try {
+        await fs.access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getFailedTests(projectRoot, coverageDir = 'coverage') {
+    coverageDir = coverageDir || 'coverage';
+    const testResultsPath = path.join(projectRoot, coverageDir, 'test-results.json');
+    let testResults = null;
+    if (!(await fileExists(testResultsPath))) {
+        throw new Error(`测试结果文件不存在: ${testResultsPath}`);
+    }
+    // 尝试读取测试结果文件
+    try {
+        testResults = JSON.parse(await fs.readFile(testResultsPath, 'utf-8'));
+    }
+    catch (err) {
+        console.error(`读取测试结果文件失败: ${err.message}`);
+    }
+    // 提取失败的测试用例信息
+    const failedTests = extractFailedTests(testResults);
+    return failedTests;
+}
+/**
+ * 解析 LCOV 格式的覆盖率报告，提取未覆盖的行号
+ * @param lcovContent LCOV 格式的覆盖率报告内容
+ */
+function parseLcovForUncoveredLines(lcovContent) {
+    const uncoveredLines = {};
+    let currentFile = null;
+    lcovContent.split('\n').forEach((line) => {
+        if (line.startsWith('SF:')) {
+            // 记录当前文件路径
+            currentFile = line.substring(3).trim();
+            uncoveredLines[currentFile] = [];
+        }
+        else if (line.startsWith('DA:') && currentFile) {
+            // 解析行覆盖率数据 (格式: DA:行号,执行次数)
+            const [lineNumberStr, executionCountStr] = line.substring(3).split(',');
+            const lineNumber = parseInt(lineNumberStr, 10);
+            const executionCount = parseInt(executionCountStr, 10);
+            // 如果执行次数为0，表示该行未被覆盖
+            if (executionCount === 0) {
+                uncoveredLines[currentFile].push(lineNumber);
+            }
+        }
+    });
+    return uncoveredLines;
+}
+/**
+ * 读取覆盖率摘要信息
+ * @param summaryPath 覆盖率摘要文件路径
+ */
+async function readCoverageSummary(summaryPath) {
+    try {
+        if (!fileExists(summaryPath)) {
+            throw new Error(`覆盖率摘要文件不存在: ${summaryPath}`);
+        }
+        return JSON.parse(await fs.readFile(summaryPath, 'utf-8'));
+    }
+    catch (error) {
+        console.error(`读取覆盖率摘要失败: ${error.message}`);
+        throw error;
+    }
+}
+/**
+ * 生成未覆盖代码行报告
+ * @param projectRoot 项目根目录
+ * @param coverage 报告文件夹，默认 'coverage'
+ */
+async function generateUncoveredLinesReport(projectRoot, coverage = 'coverage') {
+    const coverageDir = path.join(projectRoot, coverage);
+    const lcovInfoPath = path.join(coverageDir, 'lcov.info');
+    const summaryPath = path.join(coverageDir, 'coverage-summary.json');
+    // 检查覆盖率文件是否存在
+    if (!fileExists(lcovInfoPath) || !fileExists(summaryPath)) {
+        throw new Error('未找到覆盖率报告文件，请先执行测试并生成覆盖率报告');
+    }
+    // 读取覆盖率数据
+    const lcovContent = await fs.readFile(lcovInfoPath, 'utf-8');
+    const summary = await readCoverageSummary(summaryPath);
+    // 解析未覆盖的行号
+    const uncoveredLines = parseLcovForUncoveredLines(lcovContent);
+    // 构建报告对象
+    const report = {
+        total: summary.total,
+        files: {}
+    };
+    // 为每个文件添加覆盖率和未覆盖行信息
+    Object.keys(summary).forEach((filePath) => {
+        if (filePath === 'total') {
+            return;
+        }
+        // 相对路径处理
+        const relativePath = path.relative(projectRoot, filePath);
+        report.files[filePath] = {
+            coverage: summary[filePath],
+            uncoveredLines: uncoveredLines[relativePath] || []
+        };
+    });
+    return report;
+}
+/**
+ * 从 Jest 测试结果中提取失败的测试信息
+ * @param testResults Jest 测试结果对象
+ * @param projectRoot 项目根目录
+ */
+function extractFailedTests(testResults) {
+    if (!testResults || !testResults.testResults) {
+        return [];
+    }
+    const failedTests = [];
+    testResults.testResults.forEach((suite) => {
+        const testFilePath = suite.name;
+        // 单测断言失败
+        suite.assertionResults.forEach((test) => {
+            if (test.status === 'failed') {
+                const failureMessages = test.failureMessages || [];
+                const errorLocations = extractErrorLocations(failureMessages);
+                failedTests.push({
+                    testFilePath,
+                    testName: test.fullName,
+                    errorMessages: failureMessages,
+                    errorLocations
+                });
+            }
+        });
+        // 或者文件编译报错
+        if (suite.status === 'failed' && suite.message) {
+            const errorMessages = [suite.message];
+            const errorLocations = extractErrorLocations(errorMessages);
+            failedTests.push({
+                testFilePath,
+                testName: '',
+                errorMessages,
+                errorLocations
+            });
+        }
+    });
+    return failedTests;
+}
+/**
+ * 从错误消息中提取错误位置信息
+ * @param errorMessages 错误消息数组
+ * @param projectRoot 项目根目录
+ */
+function extractErrorLocations(errorMessages) {
+    const locations = [];
+    const locationRegex = /\(([^)]+):(\d+):(\d+)\)/g;
+    errorMessages.forEach((message) => {
+        let match;
+        while ((match = locationRegex.exec(message)) !== null) {
+            const [, filePath, lineStr, columnStr] = match;
+            const line = parseInt(lineStr, 10);
+            const column = parseInt(columnStr, 10);
+            locations.push({
+                filePath,
+                line,
+                column
+            });
+        }
+    });
+    return locations;
+}
+/**
+ * 缓存已加载的测试输出内容，避免重复读取文件
+ */
+const outputCache = new Map();
+/**
+ * 加载并解析Jest JSON测试报告
+ * @param jsonFilePath Jest JSON输出文件的路径
+ * @returns 一个Promise，解析为JestJsonReport对象
+ * @throws 如果文件不存在、无法读取或JSON解析失败，则抛出错误
+ */
+async function loadAndParseJsonReport(jsonFilePath) {
+    const resolvedPath = path.resolve(jsonFilePath);
+    // 检查缓存
+    if (outputCache.has(resolvedPath)) {
+        return outputCache.get(resolvedPath);
+    }
+    try {
+        // 读取文件内容
+        const fileContent = await fs.readFile(resolvedPath, 'utf8');
+        // 解析JSON
+        const report = JSON.parse(fileContent);
+        // 存入缓存
+        outputCache.set(resolvedPath, report);
+        return report;
+    }
+    catch (error) {
+        if (error.name === 'SyntaxError') {
+            throw new Error(`JSON解析失败: ${error.message}`);
+        }
+        else {
+            throw new Error(`无法读取测试输出文件: ${error.message}`);
+        }
+    }
+}
+/**
+ * 提取所有失败的测试用例概要信息
+ * @param jsonFilePath Jest JSON输出文件的路径
+ * @returns 一个Promise，解析为失败的测试用例概要数组
+ */
+async function getFailedTestSummaries(jsonFilePath) {
+    const report = await loadAndParseJsonReport(jsonFilePath);
+    const summaries = [];
+    // 遍历所有测试套件
+    for (const testSuite of report.testResults) {
+        // 遍历套件中的所有测试用例
+        for (const testCase of testSuite.assertionResults) {
+            // 只处理失败的测试用例
+            if (testCase.status === 'failed' && testCase.failureDetails && testCase.failureDetails.length > 0) {
+                summaries.push({
+                    testName: testCase.fullName,
+                    errorMessage: testCase.failureMessages[0].split('\n')[0],
+                    filePath: testSuite.name
+                });
+            }
+        }
+    }
+    return summaries;
+}
+/**
+ * 查找指定测试用例的详细错误信息
+ * @param jsonFilePath Jest JSON输出文件的路径
+ * @param testName 要查找的测试用例名称（可以是部分匹配）
+ * @returns 一个Promise，解析为匹配的测试用例详细信息数组
+ */
+async function findTestErrorDetails(jsonFilePath, testName) {
+    const report = await loadAndParseJsonReport(jsonFilePath);
+    let details = '';
+    // 遍历所有测试套件
+    for (const testSuite of report.testResults) {
+        // 遍历套件中的所有测试用例
+        for (const testCase of testSuite.assertionResults) {
+            // 只处理失败的测试用例，并且名称包含搜索词
+            if (testCase.status === 'failed' &&
+                testCase.failureDetails &&
+                testCase.failureDetails.length > 0 &&
+                (testCase.fullName.includes(testName) || testCase.title.includes(testName))) {
+                return testCase.failureMessages[0];
+            }
+        }
+    }
+    return details;
+}
+/**
+ * 清除JSON报告缓存
+ * @param jsonFilePath 可选，指定要清除缓存的文件路径；如果不提供，则清除所有缓存
+ */
+function clearJsonReportCache(jsonFilePath) {
+    if (jsonFilePath) {
+        const resolvedPath = path.resolve(jsonFilePath);
+        outputCache.delete(resolvedPath);
+    }
+    else {
+        outputCache.clear();
+    }
+}
+/**
+ * 打开浏览器访问本地的lcov-report HTML文件
+ * @param reportPath lcov-report目录的路径，默认为项目根目录下的coverage/lcov-report
+ * @returns Promise<void>
+ */
+async function openLcovReport(projectRoot, coverageDir = 'coverage', reportDir = 'lcov-report') {
+    try {
+        // 构建index.html的完整路径
+        const indexPath = path.join(projectRoot, coverageDir, reportDir, 'index.html');
+        // 检查文件是否存在
+        if (!fileExists(indexPath)) {
+            throw new Error(`LCOV报告文件不存在: ${indexPath}\n请先运行测试生成覆盖率报告`);
+        }
+        // 获取文件的绝对路径，并转换为URL格式
+        const absolutePath = path.resolve(indexPath);
+        const fileUrl = `file://${absolutePath}`;
+        console.log(`正在打开覆盖率报告: ${fileUrl}`);
+        // 根据不同操作系统，使用相应的命令打开浏览器
+        switch (process.platform) {
+            case 'darwin': // macOS
+                await execAsync(`open "${fileUrl}"`);
+                break;
+            case 'win32': // Windows
+                await execAsync(`start "" "${fileUrl}"`);
+                break;
+            default: // Linux及其他类Unix系统
+                await execAsync(`xdg-open "${fileUrl}"`);
+                break;
+        }
+        console.log('覆盖率报告已在默认浏览器中打开');
+    }
+    catch (error) {
+        console.error('打开覆盖率报告时出错:', error instanceof Error ? error.message : String(error));
+        throw error; // 重新抛出错误，允许调用者处理
+    }
+}
+//# sourceMappingURL=jest.js.map

package/dist/tools/mocha.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMochaConfigFile = createMochaConfigFile;
+exports.runMochaTests = runMochaTests;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+/**
+ * 创建 Mocha 配置文件
+ */
+async function createMochaConfigFile(configPath, options = {}) {
+    try {
+        await fs.access(configPath);
+        return null;
+    }
+    catch {
+        // 继续创建文件
+    }
+    options = typeof options === 'string' ? JSON.parse(options) : options;
+    const defaultConfig = {
+        spec: ['test/**/*.{test,spec}.{js,ts}'],
+        exclude: ['node_modules/**'],
+        extension: ['js', 'ts'],
+        require: ['ts-node/register'], // 支持 TypeScript
+        reporter: 'spec'
+    };
+    const mergedConfig = { ...defaultConfig, ...options };
+    const configContent = `module.exports = ${JSON.stringify(mergedConfig, null, 2)};\n`;
+    const dirPath = path.dirname(configPath);
+    await fs.mkdir(dirPath, { recursive: true });
+    await fs.writeFile(configPath, configContent, 'utf-8');
+    return configPath;
+}
+/**
+ * 执行 Mocha 测试（需要配合 nyc 生成覆盖率）
+ */
+async function runMochaTests(projectRoot, coverageDir = 'coverage', configPath) {
+    coverageDir = coverageDir || 'coverage';
+    return new Promise((resolve, reject) => {
+        const testResultsFile = path.join(projectRoot, coverageDir, 'test-results.json');
+        const mochaArgs = [
+            configPath ? `--config ${configPath}` : '',
+            `--reporter json --reporter-options output="${testResultsFile}"`
+        ].filter(Boolean).join(' ');
+        // 使用 nyc 生成覆盖率
+        const mochaCommand = `npx nyc --reporter=lcov --reporter=text --report-dir=${coverageDir} mocha ${mochaArgs}`;
+        const childProcess = (0, child_process_1.exec)(mochaCommand, { cwd: projectRoot, encoding: 'utf-8' });
+        let stdout = '';
+        let stderr = '';
+        childProcess.stdout?.on('data', (data) => (stdout += data));
+        childProcess.stderr?.on('data', (data) => (stderr += data));
+        childProcess.on('close', (code) => {
+            resolve({
+                testResultsFile,
+                success: code === 0,
+                noTestsFound: stderr.includes('No test files found'),
+                exitCode: code,
+                stdout,
+                stderr
+            });
+        });
+        childProcess.on('error', (err) => reject(err));
+    });
+}
+async function fileExists(path) {
+    try {
+        await fs.access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=mocha.js.map