ai-worktool 1.0.0

package/dist/testAgent.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTestAgent = startTestAgent;
+const path_1 = __importDefault(require("path"));
+const agents_1 = require("./agents");
+const tools_1 = require("./tools");
+async function startTestAgent(options) {
+    const ctrl = options.controller;
+    const log = options.onMessage || console.log;
+    let isErrorEnd = false;
+    log(`开始干活... 😎`);
+    console.log(options.projectRoot);
+    try {
+        // 工作流程：
+        // 1、检查当前项目单元测试工具是否安装好，否则安装测试工具搭建测试环境
+        const projectConfig = await (0, tools_1.detectProjectConfig)(options.projectRoot, options);
+        if (!projectConfig.isInstalled) {
+            log('项目初始化...');
+            await (0, tools_1.initProject)(options.projectRoot, projectConfig.packageManager);
+        }
+        await (0, tools_1.setupTestEnvironment)(projectConfig.projectRoot, projectConfig.packageManager, projectConfig.languages[0], projectConfig.testFramework);
+        await options.onReady?.(projectConfig);
+        let toolCalls = null;
+        let lastTestResult = null;
+        let lastFailedTest = null;
+        do {
+            if (!toolCalls) {
+                toolCalls = [];
+            }
+            // 2、先执行单测并生成单测覆盖报告
+            log('开始检查测试覆盖率...');
+            const result = await (0, tools_1.runTests)(projectConfig.projectRoot, projectConfig.testFramework, projectConfig.coverageDir, projectConfig.testConfigFile);
+            if (ctrl?.signal.aborted) {
+                break;
+            }
+            if (!result.success) {
+                // // 单测执行失败，没有发现任何需要测试的代码
+                // if (result.noTestsFound) {
+                //   log('没有发现任何需要测试的源代码...');
+                //   if (!options.fullCoverageEnd) {
+                //     await wait(options.idleTimeout || 5000);
+                //     continue;
+                //   } else {
+                //     break;
+                //   }
+                // }
+                // 上一次执行必须有写入类操作，否则不会有新的单测覆盖率变化
+                if (lastTestResult?.stderr === result.stderr &&
+                    toolCalls.every((toolCall) => !tools_1.modifyTools.includes(toolCall.functionName))) {
+                    log('没有新的代码修改，等待中...');
+                    await (0, tools_1.wait)(options.idleTimeout || 5000);
+                    continue;
+                }
+                lastTestResult = result;
+                // 单测执行失败，比如代码编译不通过
+                log('单测执行失败，开始修复...');
+                await (0, agents_1.startAgent)(options.platform, 'fixconfig', (0, agents_1.fixErrorPrompt)(result.stderr), projectConfig, options.withConversation, ctrl, options.mode, options.onMessage, async (tool) => {
+                    toolCalls.push(tool);
+                });
+                if (ctrl?.signal.aborted) {
+                    break;
+                }
+                continue;
+            }
+            // 3、要是有失败的单测先修复单测代码，重复第2步
+            const failedTests = await (0, tools_1.getFailedTests)(projectConfig.projectRoot);
+            if (ctrl?.signal.aborted) {
+                break;
+            }
+            if (failedTests.length > 0) {
+                const failedTest = failedTests[0];
+                if (lastFailedTest?.errorMessages.join('\n') === failedTest.errorMessages.join('\n') &&
+                    lastFailedTest.testFilePath === failedTest.testFilePath &&
+                    lastFailedTest.testName === failedTest.testName &&
+                    toolCalls.every((toolCall) => !tools_1.modifyTools.includes(toolCall.functionName))) {
+                    log('没有新的单测失败，等待中...');
+                    await (0, tools_1.wait)(options.idleTimeout || 5000);
+                    continue;
+                }
+                lastFailedTest = failedTest;
+                // 不能并行修复，改完行号都会变，所以每次修复完需要重新执行单测
+                log(`发现有失败的单测${path_1.default.basename(failedTest.testFilePath)}，开始修复...`);
+                await (0, agents_1.startAgent)(options.platform, 
+                // 没有testName说明是修复单测代码本身问题
+                failedTest.testName ? 'fixbug' : 'fixconfig', await (0, agents_1.fixCodePrompt)(failedTest), projectConfig, options.withConversation, ctrl, options.mode, options.onMessage, async (tool) => {
+                    toolCalls.push(tool);
+                });
+                if (ctrl?.signal.aborted) {
+                    break;
+                }
+                continue;
+            }
+            // 4、要是单测都成功并且有代码修改提交本次修改
+            if (options.autoCommit) {
+            }
+            // 5、要是有未覆盖的代码生成新的单测用例代码，重复第2步
+            const { total, files } = await (0, tools_1.generateUncoveredLinesReport)(projectConfig.projectRoot, projectConfig.coverageDir);
+            if (ctrl?.signal.aborted) {
+                break;
+            }
+            log(`当前代码总覆盖率为${parseFloat(total[options.checkPct || 'branches'].pct.toString()) || 0}%`);
+            const finished = total[options.checkPct || 'branches'].pct >= 100;
+            if (!finished) {
+                for (const filePath of Object.keys(files)) {
+                    const uncoveredLineFile = files[filePath];
+                    if (uncoveredLineFile.uncoveredLines.length <= 0) {
+                        continue;
+                    }
+                    log(`发现有未覆盖行，开始补充...`, filePath);
+                    await (0, agents_1.startAgent)(options.platform, 'addtest', await (0, agents_1.addUncoveredLinePrompt)(filePath, uncoveredLineFile), projectConfig, options.withConversation, ctrl, options.mode, options.onMessage, async (tool) => {
+                        toolCalls.push(tool);
+                    });
+                    if (ctrl?.signal.aborted) {
+                        break;
+                    }
+                }
+            }
+            else if (!options.fullCoverageEnd) {
+                await (0, tools_1.wait)(options.idleTimeout || 5000);
+            }
+            else {
+                break;
+            }
+        } while (!ctrl?.signal.aborted);
+    }
+    catch (err) {
+        if (err.name === 'AbortError') {
+            console.log('已终止');
+        }
+        else {
+            console.error(err);
+            log('发生错误,' + err.message);
+            isErrorEnd = true;
+        }
+    }
+    log(isErrorEnd ? '被下班~ 👻' : '下班下班 👋');
+}
+//# sourceMappingURL=testAgent.js.map

package/dist/tools/file.js

@@ -0,0 +1,543 @@
+"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.parseOperations = parseOperations;
+exports.searchFilesByExtension = searchFilesByExtension;
+exports.searchFilesByText = searchFilesByText;
+exports.readFile = readFile;
+exports.writeFile = writeFile;
+exports.renameFile = renameFile;
+exports.modifyLine = modifyLine;
+exports.insertLine = insertLine;
+exports.getLine = getLine;
+exports.deleteLine = deleteLine;
+exports.batchModifyLines = batchModifyLines;
+exports.deleteFolder = deleteFolder;
+const fs = __importStar(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+/**
+ * 解析操作字符串为内部操作对象
+ * @param operations 操作字符串，格式：操作类型:行号范围:内容(仅增/改需要)，多操作用逗号分隔
+ * 操作类型：i(插入)、u(更新)、d(删除)
+ * 行号范围：单行用数字，多行用数字-数字，如 3 或 5-7
+ * 内容：用双引号包裹，支持\n换行，如 "新内容" 或 "第一行\n第二行"
+ * @example 'd:5-7,u:3:"更新第3行",i:2:"插入新行"'
+ */
+function parseOperations(operations) {
+    const operationList = [];
+    const regex = /([a-z]):(\d*(?:-\d+)?)(?::"((?:[^"\\]|\\.)*)")?/g;
+    let match;
+    while ((match = regex.exec(operations)) !== null) {
+        const op = match[0];
+        const type = match[1];
+        const lineRange = match[2]; // 行号或范围
+        let text = match[3] || null; // 可选的字符串值
+        if (text) {
+            // 处理转义字符
+            text = text.replace(/\\n/g, '\n');
+        }
+        if (type === undefined || !['i', 'u', 'd'].includes(type)) {
+            throw new Error(`无效的操作类型: ${type}`);
+        }
+        let startLine, endLine;
+        // 解析行号范围
+        if (lineRange.includes('-')) {
+            [startLine, endLine] = lineRange.split('-').map((txt) => (txt ? Number(txt) : NaN));
+        }
+        else if (lineRange) {
+            startLine = Number(lineRange);
+            endLine = startLine;
+        }
+        else {
+            startLine = NaN;
+            endLine = NaN;
+        }
+        // 验证行号
+        if (isNaN(startLine) || isNaN(endLine) || startLine < 0 || endLine < startLine) {
+            throw new Error(`无效的行号范围: ${lineRange}`);
+        }
+        // 处理文本内容（转义字符）
+        let content = text?.startsWith('"') && text?.endsWith('"') ? text?.slice(1, -1) : text;
+        if (content) {
+            content = content.replace(/\\"/g, '"').replace(/\\n/g, '\n');
+        }
+        // 验证必要参数
+        if ((type === 'i' || type === 'u') && !content) {
+            throw new Error(`操作 ${op} 缺少文本内容, 文本内容需要用双引号包裹`);
+        }
+        if (type === 'd' && content) {
+            throw new Error(`删除操作 ${op} 不应包含文本内容`);
+        }
+        operationList.push({
+            type: type,
+            startLine,
+            endLine,
+            text: content
+        });
+    }
+    if (operationList.length === 0 && operations) {
+        throw new Error(`无效的操作格式: ${operations}`);
+    }
+    return operationList;
+}
+/**
+ * 在目录中递归搜索特定扩展名的文件
+ * @param directory 目录路径，如 '/src/components'
+ * @param extensions 文件扩展名数组，如 '.js|.jsx'
+ * @param includeIgnoreFiles 是否包含忽略文件，默认为false
+ * @returns 匹配的文件路径数组
+ */
+async function searchFilesByExtension(directory, extensions, includeIgnoreFiles = false) {
+    try {
+        await fs.access(directory); // 检查目录是否存在
+    }
+    catch {
+        throw new Error(`目录不存在: ${directory}`);
+    }
+    const files = [];
+    const extensionsList = extensions?.split('|') || [];
+    // 通用忽略目录
+    const commonIgnoreDirs = [
+        'node_modules',
+        '.git',
+        'dist',
+        'build',
+        'vendor',
+        '.idea',
+        '.vscode',
+        'tmp',
+        'temp',
+        'logs',
+        'docs',
+        'examples',
+        '.lock'
+    ];
+    // 其他语言忽略目录
+    const javaFamilyIgnoreDirs = ['target', 'bin', 'out', '.classpath', '.project', '.settings'];
+    const goIgnoreDirs = ['pkg', 'vendor', '.cache', 'bin'];
+    const pythonIgnoreDirs = ['__pycache__', 'venv', '.venv', 'env', 'build', 'dist', 'egg-info'];
+    const dotnetIgnoreDirs = ['obj', 'bin', 'packages', '.vs'];
+    const rubyIgnoreDirs = ['vendor/bundle', '.bundle', 'tmp', 'log'];
+    const rustIgnoreDirs = ['target'];
+    const swiftIgnoreDirs = ['.build', 'Carthage', 'Pods'];
+    // 合并所有忽略目录
+    const ignoreDirs = [
+        ...commonIgnoreDirs,
+        ...javaFamilyIgnoreDirs,
+        ...goIgnoreDirs,
+        ...pythonIgnoreDirs,
+        ...dotnetIgnoreDirs,
+        ...rubyIgnoreDirs,
+        ...rustIgnoreDirs,
+        ...swiftIgnoreDirs
+    ];
+    async function search(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!includeIgnoreFiles && ignoreDirs.includes(entry.name)) {
+                    continue;
+                }
+                await search(entryPath);
+            }
+            else if (extensionsList.some((ext) => entry.name.endsWith(ext))) {
+                files.push(entryPath);
+            }
+        }
+    }
+    await search(directory);
+    return files;
+}
+/**
+ * 在目录中递归搜索包含特定文本的文件
+ * @param directory 目录路径，如 '/src'
+ * @param text 要搜索的文本，如 'console.log'
+ * @param extensions 可选的文件扩展名过滤，如 '.js|.ts'
+ * @returns 匹配的文件路径数组
+ */
+async function searchFilesByText(directory, text, extensions) {
+    try {
+        await fs.access(directory);
+    }
+    catch {
+        throw new Error(`目录不存在: ${directory}`);
+    }
+    const files = [];
+    const extensionsList = extensions?.split('|') || [];
+    async function search(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await search(entryPath);
+            }
+            else if (!extensionsList.length || extensionsList.some((ext) => entry.name.endsWith(ext))) {
+                try {
+                    const content = await fs.readFile(entryPath, 'utf-8');
+                    if (content.includes(text)) {
+                        files.push(entryPath);
+                    }
+                }
+                catch (error) {
+                    console.warn(`无法读取文件 ${entryPath}: ${error.message}`);
+                }
+            }
+        }
+    }
+    await search(directory);
+    if (files.length === 0) {
+        throw new Error('未找到包含指定文本的文件');
+    }
+    return files;
+}
+/**
+ * 读取文件内容
+ * @param filePath 文件路径，如 'src/config/app.json'
+ * @param encoding 文件编码，默认为 'utf8'
+ * @param withRowNo 是否添加行号，默认为 false
+ * @returns 文件内容字符串
+ * @example
+ * const content = await readFile('example.txt');
+ * const contentWithLines = await readFile('example.txt', 'utf8', true);
+ */
+async function readFile(filePath, encoding = 'utf8', withRowNo = false) {
+    try {
+        encoding = encoding || 'utf8';
+        await fs.access(filePath);
+        const content = await fs.readFile(filePath, { encoding });
+        if (withRowNo) {
+            const lines = content.replace(/\r\n/g, '\n').split('\n');
+            return lines.map((line, index) => `${index + 1}:${line}`).join('\n');
+        }
+        else {
+            return content.replace(/\r\n/g, '\n');
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`文件不存在: ${filePath}`);
+        }
+        throw new Error(`读取文件失败: ${error.message}`);
+    }
+}
+/**
+ * 写入文件
+ * @param filePath 文件路径，如 'src/data/output.txt'
+ * @param content 文本内容
+ * @param encoding 文件编码，默认为 'utf8'
+ * @param overwrite 是否覆盖现有文件，默认为 false
+ * @example
+ * await writeFile('new.txt', 'Hello World');
+ * await writeFile('existing.txt', 'New content', 'utf8', true);
+ */
+async function writeFile(filePath, content, encoding = 'utf8', overwrite = true) {
+    let exists = false;
+    overwrite = overwrite ?? true;
+    try {
+        await fs.access(filePath);
+        exists = true;
+    }
+    catch { }
+    if (exists && !overwrite) {
+        throw new Error(`写入文件失败，文件已存在: ${filePath}`);
+    }
+    try {
+        encoding = encoding || 'utf8';
+        const dir = path_1.default.dirname(filePath);
+        try {
+            await fs.access(dir);
+        }
+        catch {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        await fs.writeFile(filePath, content.replace(/\r\n/g, '\n'), encoding);
+    }
+    catch (error) {
+        throw new Error(`写入文件失败: ${error.message}`);
+    }
+}
+/**
+ * 给文件或目录改名
+ * @param oldPath 原文件/目录路径
+ * @param newPath 新文件/目录路径
+ * @param overwrite 如果新路径已存在，是否覆盖，默认为 false
+ * @example
+ * await renameFile('old.txt', 'new.txt');
+ * await renameFile('docs', 'documentation', true);
+ */
+async function renameFile(oldPath, newPath, overwrite = false) {
+    try {
+        // 检查原路径是否存在
+        await fs.access(oldPath);
+    }
+    catch {
+        throw new Error(`原路径不存在: ${oldPath}`);
+    }
+    try {
+        // 检查新路径是否存在
+        await fs.access(newPath);
+        if (!overwrite) {
+            throw new Error(`新路径已存在: ${newPath}，如需覆盖请设置 overwrite 为 true`);
+        }
+        // 若新路径存在且允许覆盖，先删除新路径
+        const stats = await fs.stat(newPath);
+        if (stats.isDirectory()) {
+            await deleteFolder(newPath, { safeMode: false });
+        }
+        else {
+            await fs.unlink(newPath);
+        }
+    }
+    catch (error) {
+        // 如果是因为新路径不存在而抛出的错误，则忽略
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    try {
+        // 创建新路径所在的目录（如果不存在）
+        const newDir = path_1.default.dirname(newPath);
+        await fs.mkdir(newDir, { recursive: true });
+        // 执行重命名操作
+        await fs.rename(oldPath, newPath);
+    }
+    catch (error) {
+        throw new Error(`重命名失败: ${error.message}`);
+    }
+}
+/**
+ * 修改指定行的文本内容（支持连续多行）
+ * @param filePath 文件路径，如 'src/main.js'
+ * @param startLine 起始行号（从1开始）
+ * @param endLine 结束行号（可选，默认为startLine）
+ * @param newText 新的文本内容（字符串或字符串数组）
+ * @param encoding 文件编码，默认为 'utf8'
+ * @example
+ * await modifyLine('file.txt', 5, 5, 'New content for line 5');
+ * await modifyLine('file.txt', 3, 5, ['Line 3', 'Line 4', 'Line 5']);
+ */
+async function modifyLine(filePath, startLine, endLine = startLine, newText, encoding = 'utf8') {
+    endLine = endLine || startLine;
+    if (startLine < 1 || endLine < startLine) {
+        throw new Error(`行号参数错误: startLine=${startLine}, endLine=${endLine}`);
+    }
+    encoding = encoding || 'utf8';
+    const lines = (await readFile(filePath, encoding, false)).split('\n');
+    const lineCount = lines.length;
+    if (endLine > lineCount) {
+        throw new Error(`行号超出范围: ${endLine} (总行数: ${lineCount})`);
+    }
+    const replacementLines = Array.isArray(newText) ? newText : [newText];
+    const replaceCount = endLine - startLine + 1;
+    lines.splice(startLine - 1, replaceCount, ...replacementLines);
+    await writeFile(filePath, lines.join('\n'), encoding, true);
+}
+/**
+ * 在指定位置插入一行文本
+ * @param filePath 文件路径，如 'src/config.js'
+ * @param lineNumber 插入位置（从1开始，0表示在文件开头插入）
+ * @param text 要插入的文本
+ * @param encoding 文件编码，默认为 'utf8'
+ * @example
+ * await insertLine('file.txt', 0, 'New first line');
+ * await insertLine('file.txt', 3, 'Inserted after line 3');
+ */
+async function insertLine(filePath, lineNumber, text, encoding = 'utf8') {
+    encoding = encoding || 'utf8';
+    const lines = (await readFile(filePath, encoding, false)).split('\n');
+    lines.splice(lineNumber, 0, text);
+    await writeFile(filePath, lines.join('\n'), encoding, true);
+}
+/**
+ * 查找指定行的文本内容
+ * @param filePath 文件路径，如 'src/data.txt'
+ * @param lineNumber 行号（从1开始）
+ * @param encoding 文件编码，默认为 'utf8'
+ * @returns 指定行的文本内容
+ * @example
+ * const line5 = await getLine('file.txt', 5);
+ */
+async function getLine(filePath, lineNumber, encoding = 'utf8') {
+    encoding = encoding || 'utf8';
+    const lines = (await readFile(filePath, encoding, false)).split('\n');
+    if (lineNumber < 1 || lineNumber > lines.length) {
+        throw new Error(`行号超出范围: ${lineNumber} (总行数: ${lines.length})`);
+    }
+    return lines[lineNumber - 1];
+}
+/**
+ * 删除指定行（支持连续多行）
+ * @param filePath 文件路径，如 'src/temp.txt'
+ * @param startLine 起始行号（从1开始）
+ * @param endLine 结束行号（可选，默认为startLine）
+ * @param encoding 文件编码，默认为 'utf8'
+ * @example
+ * await deleteLine('file.txt', 5);
+ * await deleteLine('file.txt', 3, 7);
+ */
+async function deleteLine(filePath, startLine, endLine = startLine, encoding = 'utf8') {
+    if (startLine < 1 || endLine < startLine) {
+        throw new Error(`行号参数错误: startLine=${startLine}, endLine=${endLine}`);
+    }
+    encoding = encoding || 'utf8';
+    const lines = (await readFile(filePath, encoding, false)).split('\n');
+    const lineCount = lines.length;
+    if (endLine > lineCount) {
+        throw new Error(`行号超出范围: ${endLine} (总行数: ${lineCount})`);
+    }
+    const deleteCount = endLine - startLine + 1;
+    lines.splice(startLine - 1, deleteCount);
+    await writeFile(filePath, lines.join('\n'), encoding, true);
+}
+/**
+ * 多行批量操作，支持同时插入、更新和删除操作非连续行。
+ * @param filePath 文件路径，如 'src/config/app.config'
+ * @param operations 操作字符串，格式：命令:行号:"内容"(d:删除,u:更新,i:插入,后边是行号范围或行号,后边是更新内容或插入内容,内容用双引号包围),逗号分割多个命令 如 'd:5-7,u:10-12:"行10\n行11\n行12",i:1:"文件开头"'
+ * @param encoding 文件编码，默认为 'utf8'
+ * @example
+ * await batchModifyLines('file.txt', 'd:5-7,u:3:"更新第3行",i:2:"插入新行"');
+ * await batchModifyLines('file.txt', 'u:10-12:"行10\n行11\n行12",i:1:"文件开头"');
+ */
+async function batchModifyLines(filePath, operations, encoding = 'utf8') {
+    if (!operations || operations.trim() === '') {
+        throw new Error('没有提供任何操作');
+    }
+    // 解析操作字符串
+    const ops = parseOperations(operations);
+    encoding = encoding || 'utf8';
+    const originalContent = await readFile(filePath, encoding, false);
+    let lines = originalContent.split('\n');
+    const originalLineCount = lines.length;
+    // 验证所有操作的行号有效性
+    ops.forEach((op) => {
+        if (op.type === 'i') {
+            if (op.startLine < 0) {
+                // || op.startLine > originalLineCount
+                throw new Error(`插入操作行号超出范围: ${op.startLine} (原始总行数: ${originalLineCount})`);
+            }
+        }
+        else {
+            if (op.startLine < 1 || op.endLine > originalLineCount) {
+                throw new Error(`${op.type === 'u' ? '更新' : '删除'}操作行号超出范围: ${op.startLine}-${op.endLine} (原始总行数: ${originalLineCount})`);
+            }
+        }
+    });
+    // 分离并排序操作
+    const deleteOps = ops.filter((op) => op.type === 'd').sort((a, b) => b.startLine - a.startLine);
+    const updateOps = ops.filter((op) => op.type === 'u');
+    const insertOps = ops.filter((op) => op.type === 'i').sort((a, b) => a.startLine - b.startLine);
+    // 应用删除操作
+    deleteOps.forEach((op) => {
+        const lineCount = op.endLine - op.startLine + 1;
+        const deletedLinesBefore = deleteOps
+            .filter((d) => d.startLine > op.endLine)
+            .reduce((sum, d) => sum + (d.endLine - d.startLine + 1), 0);
+        const actualStartLine = op.startLine - 1 - deletedLinesBefore;
+        lines.splice(actualStartLine, lineCount);
+    });
+    // 应用更新操作
+    updateOps.forEach((op) => {
+        const lineCount = op.endLine - op.startLine + 1;
+        const deletedLinesBefore = deleteOps
+            .filter((d) => d.endLine < op.startLine)
+            .reduce((sum, d) => sum + (d.endLine - d.startLine + 1), 0);
+        const actualStartLine = op.startLine - 1 - deletedLinesBefore;
+        const replacementLines = op.text?.split('\n') || [];
+        lines.splice(actualStartLine, lineCount, ...replacementLines);
+    });
+    // 应用插入操作
+    insertOps.forEach((op) => {
+        // const deletedLinesBefore = deleteOps
+        //   .filter((d) => d.endLine <= op.startLine)
+        //   .reduce((sum, d) => sum + (d.endLine - d.startLine + 1), 0);
+        // const insertedLinesBefore = insertOps
+        //   .filter((i) => i.startLine < op.startLine)
+        //   .reduce((sum, i) => sum + (i.text?.split('\n').length || 0), 0);
+        const actualStartLine = op.startLine - 1; // - deletedLinesBefore + insertedLinesBefore;
+        const insertLines = op.text?.split('\n') || [];
+        lines.splice(actualStartLine, 0, ...insertLines);
+    });
+    // 写回文件
+    await writeFile(filePath, lines.join('\n'), encoding, true);
+}
+/**
+ * 安全递归删除文件夹及其内容
+ * @param targetPath 要删除的目录路径，如 'dist'
+ * @param options 配置选项
+ * @example
+ * await deleteFolder('dist');
+ * await deleteFolder('temp', { safeMode: false });
+ */
+async function deleteFolder(targetPath, options = {}) {
+    const { safeMode = true, allowedRoots = ['dist', 'build', 'temp', 'test-output'], logger = console.log } = options;
+    const normalizedPath = path_1.default.normalize(targetPath);
+    if (safeMode) {
+        const isAllowedRoot = allowedRoots.some((root) => normalizedPath.includes(path_1.default.sep + root + path_1.default.sep) || normalizedPath.endsWith(path_1.default.sep + root));
+        if (!isAllowedRoot) {
+            throw new Error(`删除操作已被阻止：路径 '${normalizedPath}' 不在允许的根目录列表中`);
+        }
+        if (normalizedPath === '.' || normalizedPath === '..' || normalizedPath === '/') {
+            throw new Error(`安全限制：不允许删除根目录或相对根路径`);
+        }
+    }
+    try {
+        const stats = await fs.stat(normalizedPath);
+        if (stats.isDirectory()) {
+            const entries = await fs.readdir(normalizedPath);
+            for (const entry of entries) {
+                const entryPath = path_1.default.join(normalizedPath, entry);
+                await deleteFolder(entryPath, { safeMode, allowedRoots, logger });
+            }
+            await fs.rmdir(normalizedPath);
+            logger(`已删除目录: ${normalizedPath}`);
+        }
+        else {
+            await fs.unlink(normalizedPath);
+            logger(`已删除文件: ${normalizedPath}`);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            logger(`路径不存在: ${normalizedPath}`);
+            return;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=file.js.map