ai-worktool 1.0.69 → 1.0.71

package/CHANGELOG.md

@@ -1,4 +1,4 @@
-## 1.0.69 (2025-08-18)
+## 1.0.71 (2025-08-19)
 
 
 ### Bug Fixes
@@ -10,6 +10,8 @@
 * **app:** 修正 settings 路由的挂载路径 ([2a2890b](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/2a2890be96b824f885dbd19e58f82ec3f1933a4b))
 * **coverage:** 修复代码覆盖率实时更新的问题 ([14bd1f4](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/14bd1f4eb4cc774547b55672422ace574fdec192))
 * ESM 文件导入 ([1e3b68b](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/1e3b68bf951c13fdfb0ef4fbe4e82d97f9a6c688))
+* **extension:** 优化代码结构和功能 ([51e1450](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/51e145090123c64a0384275005ede314610b3222))
+* **extension:** 添加取消登录功能并优化扩展程序的退出流程 ([8b4ddcc](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/8b4ddcca29bae106ea146128dbf38f5b9821b396))
 * **file:** 修复插入操作行号验证逻辑 ([4202d7c](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/4202d7c6524d21f200a8dced1a5e4bcba63787dd))
 * JEST无法输出colors ([3a1bd24](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/3a1bd24ba0b9b6d78dc9cdb5958f3262d08d9ded))
 * **login:** 更新客户端 ID ([bfeac59](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/bfeac590f8bae37c1a123c8356dd600ed9add4ad))
@@ -103,6 +105,7 @@
 * **commands:** 在打开订单和使用页面时添加 token 参数 ([f52c7a3](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/f52c7a349988eeec08370b4fb673bc479256ab72))
 * **commands:** 在打开订单和使用页面时添加 token 参数 ([c20e809](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/c20e809cec5a0c2c1ca886c5414730ce4893fabd))
 * **configuration:** 增加包管理器、测试框架和编程语言选择配置项 ([ec3cceb](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/ec3cceba695485010c5c710894ea2e49f57737f8))
+* **coverage:** 提升代码覆盖率测量的准确性和可读性 ([9111a6c](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/9111a6c42f204d944463113985ee53dcc7502326))
 * **dify-plugin:** 新增重命名文件或目录的功能 ([9bb6961](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/9bb69613a28aba6859f72b14b2aa1a586ac9ca70))
 * **extension:** 重构 Webview 并添加覆盖率报告功能 ([fd8a62b](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/fd8a62b79aff4c03af8b56779d607f01d65c175a))
 * **jianguoke:** 优化工具调用信息格式化及消息 ID 生成 ([1b240e7](https://codeup.aliyun.com/666cf9ed29ecbe23053513a3/JianGuoKe/ai-worktools/commits/1b240e7fbcabb2112789c116b7f483308c184fce))

package/dist/agents/prompt.js

@@ -32,12 +32,40 @@ ${await (0, tools_1.readFile)(failedTest.testFilePath, 'utf8', true)}
 \`\`\``;
 }
 async function addUncoveredLinePrompt(srcPath, report) {
-    return `源文件"${path_1.default.resolve(srcPath)}"的单元测试覆盖率是${report.coverage.branches.pct}%, 还有行号是"${report.uncoveredLines.join(',')}"未覆盖单测。
+    const pctType = report.coverage.functions.pct < 100
+        ? '函数'
+        : report.coverage.lines.pct < 100
+            ? '行'
+            : report.coverage.branches.pct < 100
+                ? '分支'
+                : '语句';
+    const pct = report.coverage.functions.pct < 100
+        ? report.coverage.functions.pct
+        : report.coverage.lines.pct < 100
+            ? report.coverage.lines.pct
+            : report.coverage.branches.pct < 100
+                ? report.coverage.branches.pct
+                : report.coverage.statements.pct;
+    const unitName = report.coverage.functions.pct < 100 ? '函数' : '行';
+    const lines = (report.uncoveredLines.functions ||
+        report.uncoveredLines.lines ||
+        report.uncoveredLines.branches ||
+        report.uncoveredLines.statements).join(',');
+    return (`源文件"${path_1.default.resolve(srcPath)}"的单元测试${pctType}覆盖率是${pct}%, 还有行号是"${lines}"的${unitName}未完全覆盖单测。
 
 源文件内容如下:
 \`\`\`
 ${await (0, tools_1.readFile)(srcPath, 'utf8', true)}
-\`\`\``;
+\`\`\`` +
+        ((report.coverage.functions.total > 0 && report.coverage.functions.pct > 0) ||
+            (report.coverage.lines.total > 0 && report.coverage.lines.pct > 0) ||
+            (report.coverage.branches.total > 0 && report.coverage.branches.pct > 0) ||
+            (report.coverage.statements.total > 0 && report.coverage.statements.pct > 0)
+            ? `
+
+查找已有测试文件增加单测代码。
+`
+            : ''));
 }
 async function addUncoveredFilePrompt(total, files) {
     const testFileNames = files.map((it) => it.filePath);

package/dist/agents/toolCall.js

@@ -103,7 +103,7 @@ function inferCodeTypeFromExtension(filePath) {
  * @param argsObj 包含参数的对象
  * @returns 函数执行结果
  */
-async function callWithObject(name, argsObj, cwd) {
+async function callWithObject(name, argsObj, projectDir) {
     const fn = tools[name];
     if (!fn) {
         throw new Error(`Tool ${name} not found`);
@@ -113,8 +113,10 @@ async function callWithObject(name, argsObj, cwd) {
     // 从对象中提取参数值
     const args = paramNames.map((name) => {
         // 转成决定路径
-        if (name === 'filePath' && cwd && !path_1.default.isAbsolute(argsObj[name])) {
-            return path_1.default.resolve(cwd, argsObj[name]);
+        if ((name === 'filePath' || name === 'oldPath' || name === 'newPath' || name === 'directory') &&
+            projectDir &&
+            !path_1.default.isAbsolute(argsObj[name])) {
+            return path_1.default.resolve(projectDir, argsObj[name]);
         }
         return argsObj[name];
     });
@@ -172,7 +174,7 @@ toolCall, root, result) {
     root = root || '/';
     const params = toolCall.params || {};
     if (toolCall.function_name === 'readFile') {
-        const outputResult = result ? (result?.success ? ` ✅` : result?.message || '❌') : '';
+        const outputResult = result ? (result?.success ? ` ✅` : ` ❌${result?.message}`) : '';
         const filePath = params[0] || params.filePath;
         return `读取文件：${formatDisplayText(filePath ? (path_1.default.isAbsolute(filePath) ? path_1.default.relative(root, filePath) : filePath) : '')}${outputResult}`;
     }
@@ -181,21 +183,24 @@ toolCall, root, result) {
         toolCall.function_name === 'modifyLine' ||
         toolCall.function_name === 'deleteLine' ||
         toolCall.function_name === 'batchModifyLines') {
-        const outputResult = result ? (result?.success ? ` ✅` : result?.message || '❌') : '';
+        const outputResult = result ? (result?.success ? ` ✅` : ` ❌${result?.message}`) : '';
         const filePath = params[0] || params.filePath;
         return `修改文件：${formatDisplayText(filePath ? (path_1.default.isAbsolute(filePath) ? path_1.default.relative(root, filePath) : filePath) : '')}${outputResult}`;
     }
     if (toolCall.function_name === 'searchFilesByExtension') {
         const outputResult = result
             ? result?.success
-                ? ` => ${formatDisplayText(result.data.replaceAll(root + path_1.default.sep, '').replaceAll('- ', '').replaceAll('\n', ' '))} ✅`
-                : result?.message || '❌'
+                ? ` => ${formatDisplayText(result.data
+                    .replaceAll(root + path_1.default.sep, '')
+                    .replaceAll('- ', '')
+                    .replaceAll('\n', ' '))} ✅`
+                : ` ❌${result?.message}`
             : '';
         const searchPath = params[0] || params.directory;
         const exts = params[1] || params.extensions || '';
         return `检索文件：${searchPath ? (path_1.default.isAbsolute(searchPath) ? path_1.default.relative(root, searchPath) : searchPath) : ''}${exts ? '/*' : ''}${exts}${outputResult}`;
     }
-    const outputResult = result ? (result?.success ? ` ✅` : result?.message || '❌') : '';
+    const outputResult = result ? (result?.success ? ` ✅` : ` ❌${result?.message}`) : '';
     return toolCall.function_name + outputResult;
 }
 //# sourceMappingURL=toolCall.js.map

package/dist/report.js

@@ -0,0 +1,644 @@
+"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.DEFAULT_PORT = void 0;
+exports.startServer = startServer;
+exports.stopServer = stopServer;
+exports.addOrUpdateProject = addOrUpdateProject;
+exports.removeProject = removeProject;
+exports.getProjects = getProjects;
+exports.openLcovReport = openLcovReport;
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs/promises"));
+const fsSync = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url = __importStar(require("url"));
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+// 转换exec为Promise形式，便于async/await使用
+const execAsync = util_1.default.promisify(child_process_1.exec);
+// 配置
+exports.DEFAULT_PORT = 3000;
+const LCOV_REPORT_DIR = 'lcov-report';
+// 服务器状态变量
+let server = null;
+let serverPort;
+const watchers = new Map(); // 每个项目一个监控器，key为项目名
+let lastChangeTime = new Map(); // 每个项目的最后修改时间，key为项目名
+const clients = [];
+let projectsConfig = {}; // 项目配置映射
+// MIME类型映射表
+const mimeTypes = {
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon'
+};
+// 获取MIME类型
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+// 解析URL，获取项目名和相对路径
+function parseUrlPath(pathname) {
+    // 移除开头的斜杠并分割路径
+    const parts = pathname.replace(/^\/+/, '').split('/');
+    // 第一个部分是项目名
+    const project = parts[0] || '';
+    // 剩余部分组成相对路径
+    const relativePath = parts.slice(1).join('/') || '';
+    return { project, relativePath };
+}
+// 查找项目的lcov-report目录
+async function findProjectReportDir(projectName) {
+    // 检查项目是否在配置中
+    if (!projectsConfig[projectName])
+        return null;
+    try {
+        const projectDir = projectsConfig[projectName];
+        const reportPath = path.join(projectDir, LCOV_REPORT_DIR);
+        const stats = await fs.stat(reportPath);
+        return stats.isDirectory() ? reportPath : null;
+    }
+    catch (err) {
+        return null;
+    }
+}
+// 检查项目路径是否有效
+async function validateProjectPath(projectPath) {
+    try {
+        const stats = await fs.stat(projectPath);
+        if (!stats.isDirectory()) {
+            return { valid: false, error: '路径不是有效的目录' };
+        }
+        return { valid: true };
+    }
+    catch (err) {
+        return { valid: false, error: '路径不存在或无法访问' };
+    }
+}
+// 验证多个项目配置是否有效
+async function validateProjectsConfig(config) {
+    const errors = {};
+    for (const [projectName, projectPath] of Object.entries(config)) {
+        const { valid, error } = await validateProjectPath(projectPath);
+        if (!valid && error) {
+            errors[projectName] = error;
+        }
+    }
+    return { valid: Object.keys(errors).length === 0, errors };
+}
+// 设置项目的文件监控
+function setupProjectWatcher(projectName) {
+    const projectPath = projectsConfig[projectName];
+    if (!projectPath)
+        return;
+    // 如果已有监控器，关闭它
+    if (watchers.has(projectName)) {
+        watchers.get(projectName).close();
+    }
+    // 监控整个项目目录
+    const watcher = fsSync.watch(projectPath, { recursive: true }, (eventType) => {
+        if (eventType === 'change' || eventType === 'rename') {
+            const time = Date.now();
+            lastChangeTime.set(projectName, time);
+            console.log(`项目 ${projectName} 的文件变化 detected at ${new Date(time).toLocaleTimeString()}`);
+            // 通知该项目的所有客户端
+            const projectClients = clients.filter((c) => c.project === projectName);
+            projectClients.forEach(({ res }) => {
+                const index = clients.findIndex((c) => c.res === res);
+                if (index !== -1) {
+                    clients.splice(index, 1);
+                    sendChangeNotification(res, projectName);
+                }
+            });
+        }
+    });
+    watchers.set(projectName, watcher);
+    console.log(`正在监控项目变化: ${projectName} -> ${projectPath}`);
+    return watcher;
+}
+// 发送变化通知
+function sendChangeNotification(response, projectName) {
+    response.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive'
+    });
+    response.write(`data: ${JSON.stringify({
+        changed: true,
+        time: Date.now(),
+        project: projectName
+    })}\n\n`);
+    response.end();
+}
+// 注入静默刷新脚本到HTML内容
+function injectSilentRefreshScript(htmlContent, projectName) {
+    // 项目名为空表示是根页面，不需要处理
+    if (!projectName) {
+        return htmlContent;
+    }
+    // 注入静默刷新脚本
+    const script = `
+    <script>
+      // 当前项目名称
+      const currentProject = '${projectName}';
+      
+      // 保存当前滚动位置
+      function saveScrollPosition() {
+        return {
+          x: window.scrollX,
+          y: window.scrollY
+        };
+      }
+      
+      // 恢复滚动位置
+      function restoreScrollPosition(pos) {
+        window.scrollTo(pos.x, pos.y);
+      }
+      
+      // 重新加载CSS
+      function reloadStylesheets() {
+        const links = document.querySelectorAll('link[rel="stylesheet"]');
+        links.forEach(link => {
+          const href = link.getAttribute('href');
+          if (href) {
+            // 添加时间戳防止缓存
+            const newHref = href + (href.includes('?') ? '&' : '?') + 't=' + Date.now();
+            link.setAttribute('href', newHref);
+          }
+        });
+      }
+      
+      // 静默更新页面内容
+      async function updatePageContent() {
+        try {
+          // 保存当前滚动位置
+          const scrollPos = saveScrollPosition();
+          
+          // 获取当前页面的HTML
+          const response = await fetch(window.location.pathname);
+          if (!response.ok) throw new Error('获取页面失败');
+          
+          const newHtml = await response.text();
+          const parser = new DOMParser();
+          const newDocument = parser.parseFromString(newHtml, 'text/html');
+          
+          // 更新body内容
+          document.body.innerHTML = newDocument.body.innerHTML;
+          
+          // 重新加载样式表
+          reloadStylesheets();
+          
+          // 恢复滚动位置
+          restoreScrollPosition(scrollPos);
+          
+          console.log(\`项目 \${currentProject} 页面已静默更新\`);
+        } catch (error) {
+          console.error('更新页面时出错:', error);
+          // 出错时回退到整页刷新
+          window.location.reload();
+        }
+      }
+      
+      // 长轮询检查变化
+      function checkForChanges() {
+        fetch(\`/\${currentProject}/__watch\`)
+          .then(response => {
+            if (response.ok) {
+              return response.text();
+            }
+            throw new Error('轮询响应错误');
+          })
+          .then(data => {
+            // 解析服务器发送的事件
+            if (data.startsWith('data:')) {
+              const jsonData = JSON.parse(data.substring(5).trim());
+              
+              // 项目页面的内容变化
+              if (jsonData.changed && jsonData.project === currentProject) {
+                console.log(\`检测到项目 \${currentProject} 的文件变化，正在更新页面...\`);
+                updatePageContent();
+              }
+            }
+            // 继续轮询
+            checkForChanges();
+          })
+          .catch(error => {
+            console.error('轮询错误:', error);
+            // 出错后延迟重试
+            setTimeout(checkForChanges, 1000);
+          });
+      }
+      
+      // 页面加载后开始轮询
+      window.addEventListener('load', checkForChanges);
+    </script>
+  `;
+    // 将脚本注入到</body>标签前
+    return htmlContent.replace('</body>', `${script}</body>`);
+}
+// 处理请求
+async function handleRequest(request, response) {
+    try {
+        const parsedUrl = url.parse(request.url || '', true);
+        const pathname = parsedUrl.pathname || '/';
+        // 解析URL获取项目名和相对路径
+        const { project: projectName, relativePath } = parseUrlPath(pathname);
+        // 处理根路径请求，显示项目列表
+        if (!projectName) {
+            return handleRootRequest(response);
+        }
+        // 检查项目是否存在于配置中
+        if (!projectsConfig[projectName]) {
+            response.writeHead(404, { 'Content-Type': 'text/plain' });
+            response.end(`项目 "${projectName}" 不存在于配置中`);
+            return;
+        }
+        // 处理项目的监控请求
+        if (relativePath === '__watch') {
+            const clientLastChange = Number(parsedUrl.query.lastChange) || 0;
+            const projectLastChange = lastChangeTime.get(projectName) || 0;
+            if (projectLastChange > clientLastChange) {
+                sendChangeNotification(response, projectName);
+            }
+            else {
+                // 保持连接等待
+                clients.push({ res: response, project: projectName });
+                // 10秒后超时
+                setTimeout(() => {
+                    const index = clients.findIndex((c) => c.res === response);
+                    if (index !== -1) {
+                        clients.splice(index, 1);
+                        response.writeHead(204); // 无内容
+                        response.end();
+                    }
+                }, 10000);
+            }
+            return;
+        }
+        // 查找项目的报告目录
+        const reportDir = await findProjectReportDir(projectName);
+        if (!reportDir) {
+            response.writeHead(404, { 'Content-Type': 'text/plain' });
+            response.end(`项目 "${projectName}" 未找到或不包含 ${LCOV_REPORT_DIR} 目录`);
+            return;
+        }
+        // 设置项目的文件监控（如果尚未设置）
+        if (!watchers.has(projectName)) {
+            setupProjectWatcher(projectName);
+        }
+        // 处理静态文件请求
+        let filePath = path.join(reportDir, relativePath);
+        // 防止路径遍历攻击
+        if (!filePath.startsWith(reportDir)) {
+            response.writeHead(403, { 'Content-Type': 'text/plain' });
+            response.end('禁止访问');
+            return;
+        }
+        // 检查文件状态
+        let stats;
+        try {
+            stats = await fs.stat(filePath);
+        }
+        catch (err) {
+            response.writeHead(404, { 'Content-Type': 'text/plain' });
+            response.end(`文件未找到: ${relativePath}`);
+            return;
+        }
+        // 如果是目录，尝试加载index.html
+        if (stats.isDirectory()) {
+            filePath = path.join(filePath, 'index.html');
+            try {
+                await fs.stat(filePath);
+            }
+            catch (err) {
+                response.writeHead(404, { 'Content-Type': 'text/plain' });
+                response.end(`目录下未找到index.html: ${relativePath}`);
+                return;
+            }
+        }
+        // 读取文件
+        const data = await fs.readFile(filePath);
+        const mimeType = getMimeType(filePath);
+        response.writeHead(200, { 'Content-Type': mimeType });
+        // 如果是HTML文件，注入静默刷新脚本
+        if (mimeType === 'text/html') {
+            const htmlContent = data.toString();
+            const modifiedContent = injectSilentRefreshScript(htmlContent, projectName);
+            response.end(modifiedContent);
+        }
+        else {
+            response.end(data);
+        }
+    }
+    catch (error) {
+        console.error('处理请求时出错:', error);
+        response.writeHead(500, { 'Content-Type': 'text/plain' });
+        response.end('服务器内部错误');
+    }
+}
+// 处理根路径请求，显示项目列表
+async function handleRootRequest(response) {
+    // 生成项目列表HTML
+    const html = `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <title>覆盖率报告项目列表</title>
+      <style>
+        body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+        h1 { color: #333; }
+        .project-list { list-style: none; padding: 0; }
+        .project-item { margin: 10px 0; padding: 10px; border: 1px solid #eee; border-radius: 4px; }
+        .project-name { font-weight: bold; }
+        .project-path { color: #666; font-size: 0.9em; margin-top: 5px; }
+        a { color: #007bff; text-decoration: none; }
+        a:hover { text-decoration: underline; }
+        .status { margin-left: 10px; padding: 2px 6px; border-radius: 3px; font-size: 0.8em; }
+        .status-ok { background-color: #d4edda; color: #155724; }
+        .status-error { background-color: #f8d7da; color: #721c24; }
+      </style>
+    </head>
+    <body>
+      <h1>覆盖率报告项目列表</h1>
+      <ul class="project-list">
+        ${Object.entries(projectsConfig)
+        .map(([projectName, projectPath]) => `
+          <li class="project-item">
+            <div>
+              <a href="/${projectName}" class="project-name">${projectName}</a>
+              ${(async () => {
+        const reportDir = await findProjectReportDir(projectName);
+        return reportDir
+            ? '<span class="status status-ok">正常</span>'
+            : '<span class="status status-error">缺少报告目录</span>';
+    })()
+        .then((status) => status)
+        .catch(() => '')}
+            </div>
+            <div class="project-path">${projectPath}</div>
+          </li>
+        `)
+        .join('')}
+      </ul>
+      ${Object.keys(projectsConfig).length === 0 ? '<p>当前没有配置任何项目。</p>' : ''}
+    </body>
+    </html>
+  `;
+    response.writeHead(200, { 'Content-Type': 'text/html' });
+    response.end(html);
+}
+/**
+ * 获取可用端口
+ * @returns 可用端口号
+ */
+function getAvailablePort() {
+    return new Promise((resolve, reject) => {
+        const tempServer = http.createServer();
+        tempServer.listen(0, 'localhost', () => {
+            const address = tempServer.address();
+            if (typeof address === 'object' && address && address.port) {
+                const port = address.port;
+                tempServer.close(() => resolve(port));
+            }
+            else {
+                tempServer.close();
+                reject(new Error('无法获取可用端口'));
+            }
+        });
+    });
+}
+/**
+ * 启动LCOV报告服务器
+ * @param projects 项目配置映射：{ 项目名: 项目实际路径 }
+ * @param port 服务器端口，默认为3000
+ * @returns 服务器实例和启动信息
+ */
+async function startServer(projects = {}, port) {
+    // 停止已运行的服务器
+    if (server) {
+        await stopServer();
+    }
+    // 验证项目配置
+    const { valid, errors } = await validateProjectsConfig(projects);
+    if (!valid) {
+        const errorMsg = `项目配置无效:\n${Object.entries(errors)
+            .map(([name, err]) => `- ${name}: ${err}`)
+            .join('\n')}`;
+        console.error(errorMsg);
+        throw new Error(errorMsg);
+    }
+    // 保存项目配置
+    projectsConfig = { ...projects };
+    // 为所有项目设置监控
+    //   Object.keys(projectsConfig).forEach((projectName) => {
+    //     setupProjectWatcher(projectName);
+    //   });
+    // 如果没有配置项目，给出警告
+    if (Object.keys(projectsConfig).length === 0) {
+        console.warn('警告: 未配置任何项目，服务器将无法提供有效内容');
+    }
+    serverPort = port || (await getAvailablePort());
+    // 创建服务器
+    server = http.createServer((req, res) => {
+        handleRequest(req, res).catch((err) => {
+            console.error('未捕获的请求错误:', err);
+            if (!res.finished) {
+                res.writeHead(500, { 'Content-Type': 'text/plain' });
+                res.end('服务器错误');
+            }
+        });
+    });
+    // 启动服务器
+    return new Promise((resolve, reject) => {
+        server
+            .listen(serverPort, () => {
+            console.log(`服务器运行在 http://localhost:${serverPort}`);
+            console.log('配置的项目:');
+            Object.entries(projectsConfig).forEach(([name, path]) => {
+                console.log(`- ${name}: ${path}`);
+            });
+            console.log(`访问 http://localhost:${serverPort} 查看项目列表`);
+            resolve({ server: server, port: serverPort, projects: { ...projectsConfig } });
+        })
+            .on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+/**
+ * 停止LCOV报告服务器
+ * @returns 停止成功的Promise
+ */
+async function stopServer() {
+    return new Promise((resolve) => {
+        // 关闭所有文件监控
+        watchers.forEach((watcher) => watcher.close());
+        watchers.clear();
+        lastChangeTime.clear();
+        // 关闭客户端连接
+        clients.forEach(({ res }) => {
+            if (!res.finished) {
+                res.end();
+            }
+        });
+        clients.length = 0;
+        // 清空项目配置
+        projectsConfig = {};
+        // 关闭服务器
+        if (server) {
+            server.close(() => {
+                console.log('服务器已关闭');
+                server = null;
+                resolve();
+            });
+        }
+        else {
+            resolve();
+        }
+    });
+}
+/**
+ * 添加或更新项目
+ * @param projectName 项目名称
+ * @param projectPath 项目实际路径
+ * @returns 操作结果
+ */
+async function addOrUpdateProject(projectName, projectPath) {
+    if (!server) {
+        return {
+            success: false,
+            error: '服务器未启动',
+            projects: { ...projectsConfig }
+        };
+    }
+    // 验证项目路径
+    const { valid, error } = await validateProjectPath(projectPath);
+    if (!valid && error) {
+        return {
+            success: false,
+            error,
+            projects: { ...projectsConfig }
+        };
+    }
+    // 添加或更新项目配置
+    projectsConfig[projectName] = projectPath;
+    // 设置或更新监控
+    //   setupProjectWatcher(projectName);
+    console.log(`项目已${projectsConfig.hasOwnProperty(projectName) ? '更新' : '添加'}: ${projectName} -> ${projectPath}`);
+    return {
+        success: true,
+        projects: { ...projectsConfig }
+    };
+}
+/**
+ * 删除项目
+ * @param projectName 要删除的项目名称
+ * @returns 操作结果
+ */
+async function removeProject(projectName) {
+    if (!server) {
+        return {
+            success: false,
+            error: '服务器未启动',
+            projects: { ...projectsConfig }
+        };
+    }
+    // 检查项目是否存在
+    if (!projectsConfig[projectName]) {
+        return {
+            success: false,
+            error: `项目 "${projectName}" 不存在`,
+            projects: { ...projectsConfig }
+        };
+    }
+    // 关闭并移除监控
+    if (watchers.has(projectName)) {
+        watchers.get(projectName).close();
+        watchers.delete(projectName);
+        lastChangeTime.delete(projectName);
+    }
+    // 从配置中删除项目
+    delete projectsConfig[projectName];
+    console.log(`项目已删除: ${projectName}`);
+    return {
+        success: true,
+        projects: { ...projectsConfig }
+    };
+}
+/**
+ * 获取当前所有项目配置
+ * @returns 项目配置
+ */
+function getProjects() {
+    return { ...projectsConfig };
+}
+async function openLcovReport(projectName, projectRoot) {
+    try {
+        if (!server) {
+            await startServer();
+        }
+        await addOrUpdateProject(projectName, projectRoot);
+        const url = `http://localhost:${serverPort}/${projectName}/index.html`;
+        console.log(`正在打开覆盖率报告: ${url}`);
+        // 根据不同操作系统，使用相应的命令打开浏览器
+        switch (process.platform) {
+            case 'darwin': // macOS
+                await execAsync(`open "${url}"`);
+                break;
+            case 'win32': // Windows
+                await execAsync(`start "" "${url}"`);
+                break;
+            default: // Linux及其他类Unix系统
+                await execAsync(`xdg-open "${url}"`);
+                break;
+        }
+        console.log('覆盖率报告已在默认浏览器中打开');
+    }
+    catch (error) {
+        console.error('打开覆盖率报告时出错:', error instanceof Error ? error.message : String(error));
+        throw error; // 重新抛出错误，允许调用者处理
+    }
+}
+//# sourceMappingURL=report.js.map

package/dist/testAgent.js

@@ -92,16 +92,22 @@ async function startTestAgent(options) {
             if (options.autoCommit) {
             }
             // 5、要是有未覆盖的代码生成新的单测用例代码，重复第2步
-            const { total, files } = await (0, tools_1.generateUncoveredLinesReport)(projectConfig.projectRoot, projectConfig.coverageDir, options.measureType);
+            const { total, files } = await (0, tools_1.generateUncoveredLinesReport)(projectConfig.projectRoot, projectConfig.coverageDir);
             if (ctrl?.signal.aborted) {
                 break;
             }
-            output(`当前代码总覆盖率为${parseFloat(total[options.measureType || 'branches'].pct.toString()) || 0}%。`);
-            const finished = total[options.measureType || 'branches'].pct >= 100;
+            output(`当前代码总覆盖率为 Statements:${parseFloat(total['statements'].pct.toString()) || 0}%  Branches:${parseFloat(total['branches'].pct.toString()) || 0}% Functions:${parseFloat(total['functions'].pct.toString()) || 0}% Lines:${parseFloat(total['lines'].pct.toString()) || 0}% `);
+            const finished = total.functions.pct >= 100 &&
+                total.lines.pct >= 100 &&
+                total.branches.pct >= 100 &&
+                total.statements.pct >= 100;
             if (!finished) {
                 if (files.length) {
-                    for (const uncoveredLineFile of files.sort((a, b) => a.lines.coverage.branches.pct - b.lines.coverage.branches.pct)) {
-                        output(`发现有未覆盖行，开始补充...`);
+                    for (const uncoveredLineFile of files.sort((a, b) => a.lines.coverage.functions.pct - b.lines.coverage.functions.pct ||
+                        a.lines.coverage.lines.pct - b.lines.coverage.lines.pct ||
+                        a.lines.coverage.branches.pct - b.lines.coverage.branches.pct ||
+                        a.lines.coverage.statements.pct - b.lines.coverage.statements.pct)) {
+                        output(`发现有未覆盖代码，开始补充...`);
                         await (0, agents_1.startAgent)(options.platform, 'addtest', await (0, agents_1.addUncoveredLinePrompt)(uncoveredLineFile.filePath, uncoveredLineFile.lines), projectConfig, options.withConversation, ctrl, options.mode, options.onMessage, async (tool) => {
                             toolCalls.push(tool);
                         });

package/dist/tools/file.js

@@ -297,7 +297,7 @@ async function writeFile(filePath, content, encoding = 'utf8', overwrite = true)
             await fs.mkdir(dir, { recursive: true });
         }
         const data = content.replace(/\r\n/g, '\n');
-        const old = process.env.NODE_ENV === 'test' ? await fs.readFile(filePath, encoding) : '';
+        const old = process.env.NODE_ENV === 'test' && exists ? await fs.readFile(filePath, encoding) : '';
         await fs.writeFile(filePath, data, encoding);
         if (process.env.NODE_ENV === 'test') {
             // 比较文件差异

package/dist/tools/jest.js

@@ -232,21 +232,41 @@ function parseLcovForUncoveredLines(lcovContent, measureType = 'branches') {
     const uncoveredLines = {};
     let currentFile = null;
     const DAKey = measureType === 'branches' ? 'BRDA' : measureType === 'functions' ? 'FNDA' : 'DA';
-    lcovContent.split('\n').forEach((line) => {
+    const lines = lcovContent.split('\n');
+    const fns = new Map();
+    lines.forEach((line) => {
         if (line.startsWith('SF:')) {
             // 记录当前文件路径
             currentFile = line.substring(3).trim();
             uncoveredLines[currentFile] = [];
+            fns.clear();
+        }
+        else if (line.startsWith('FN:')) {
+            // FN:35,(anonymous_23)
+            const lineNumber = parseInt(line.substring(3, line?.lastIndexOf(',')), 10);
+            const functionName = line.substring(line?.lastIndexOf(',') + 1);
+            fns.set(functionName, lineNumber);
         }
         else if (line.startsWith(DAKey) && currentFile) {
-            // 解析行覆盖率数据 (格式: DA:行号,执行次数)
-            // BRDA:53,0,0,8 最后是执行次数
-            const [lineNumberStr, ...executionCountStr] = line.substring(DAKey.length + 1).split(',');
-            const lineNumber = parseInt(lineNumberStr, 10);
-            const executionCount = parseInt(executionCountStr[executionCountStr.length - 1], 10);
-            // 如果执行次数为0，表示该行未被覆盖
-            if (executionCount === 0) {
-                uncoveredLines[currentFile].push(lineNumber);
+            if (measureType === 'functions') {
+                // FNDA:3,(anonymous_23)
+                const [executionCountStr, functionName] = line.substring(DAKey.length + 1).split(',');
+                const lineNumber = fns.get(functionName);
+                const executionCount = parseInt(executionCountStr, 10);
+                if (executionCount === 0 && !uncoveredLines[currentFile].includes(lineNumber)) {
+                    uncoveredLines[currentFile].push(lineNumber);
+                }
+            }
+            else {
+                // 解析行覆盖率数据 (格式: DA:行号,执行次数)
+                // BRDA:53,0,0,8 第三位是执行次数
+                const [lineNumberStr, ...executionCountStr] = line.substring(DAKey.length + 1).split(',');
+                const lineNumber = parseInt(lineNumberStr, 10);
+                const executionCount = parseInt(executionCountStr[DAKey === 'BRDA' ? 2 : 0], 10);
+                // 如果执行次数为0，表示该行未被覆盖
+                if (executionCount === 0 && !uncoveredLines[currentFile].includes(lineNumber)) {
+                    uncoveredLines[currentFile].push(lineNumber);
+                }
             }
         }
     });
@@ -273,11 +293,10 @@ async function readCoverageSummary(summaryPath) {
  * @param projectRoot 项目根目录
  * @param coverage 报告文件夹，默认 'coverage'
  */
-async function generateUncoveredLinesReport(projectRoot, coverage = 'coverage', measureType) {
+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');
-    measureType = measureType || 'branches';
     // 检查覆盖率文件是否存在
     if (!fileExists(lcovInfoPath) || !fileExists(summaryPath)) {
         throw new Error('未找到覆盖率报告文件，请先执行测试并生成覆盖率报告');
@@ -286,7 +305,10 @@ async function generateUncoveredLinesReport(projectRoot, coverage = 'coverage',
     const lcovContent = await fs.readFile(lcovInfoPath, 'utf-8');
     const summary = await readCoverageSummary(summaryPath);
     // 解析未覆盖的行号
-    const uncoveredLines = parseLcovForUncoveredLines(lcovContent, measureType);
+    const uncoveredFNLines = parseLcovForUncoveredLines(lcovContent, 'functions');
+    const uncoveredLNLines = parseLcovForUncoveredLines(lcovContent, 'lines');
+    const uncoveredBRLines = parseLcovForUncoveredLines(lcovContent, 'branches');
+    const uncoveredSTLines = parseLcovForUncoveredLines(lcovContent, 'statements');
     // 构建报告对象
     const report = {
         total: summary.total,
@@ -296,14 +318,23 @@ async function generateUncoveredLinesReport(projectRoot, coverage = 'coverage',
     Object.keys(summary).forEach((filePath) => {
         // 相对路径处理
         const relativePath = path.relative(projectRoot, filePath);
-        if (filePath === 'total' || (uncoveredLines[relativePath] || []).length === 0) {
+        if (filePath === 'total' ||
+            ((uncoveredBRLines[relativePath] || []).length === 0 &&
+                (uncoveredFNLines[relativePath] || []).length === 0 &&
+                (uncoveredLNLines[relativePath] || []).length === 0 &&
+                (uncoveredSTLines[relativePath] || []).length === 0)) {
             return;
         }
         report.files.push({
             filePath,
             lines: {
                 coverage: summary[filePath],
-                uncoveredLines: uncoveredLines[relativePath]
+                uncoveredLines: {
+                    branches: uncoveredBRLines[relativePath],
+                    functions: uncoveredFNLines[relativePath],
+                    lines: uncoveredLNLines[relativePath],
+                    statements: uncoveredSTLines[relativePath]
+                }
             }
         });
     });

package/dist/tools/project.js

@@ -56,10 +56,10 @@ async function detectProjectConfig(projectRoot, defaultConfig) {
     await detectLanguages(projectRoot, config);
     // 检测源代码目录
     await detectSrcDir(projectRoot, config);
-    // 检测测试相关配置
-    await detectTestConfig(projectRoot, config);
     // 检测项目类型（前端/后端/全栈）
     await detectProjectType(projectRoot, config);
+    // 检测测试相关配置
+    await detectTestConfig(projectRoot, config);
     // 检测框架信息
     await detectFramework(projectRoot, config);
     // 检测Git配置
@@ -170,6 +170,10 @@ async function detectTestConfig(projectRoot, config) {
     }
     // 检测测试目录
     const possibleTestDirs = ['test', 'tests', '__tests__', 'spec', 'specs'];
+    if (config.srcDir) {
+        // __tests__：这是前端项目（尤其是使用 Jest 作为测试框架的 React 项目）中比较有特色的放置方式。
+        possibleTestDirs.push(path_1.default.join(config.srcDir, '__tests__'));
+    }
     for (const dir of possibleTestDirs) {
         const dirPath = path_1.default.join(projectRoot, dir);
         if (await directoryExists(dirPath)) {
@@ -238,16 +242,28 @@ async function detectTestConfig(projectRoot, config) {
     const extensions = new Set();
     if (config.languages?.includes('javascript')) {
         extensions.add('js');
+        if (config.projectType === 'frontend') {
+            extensions.add('jsx');
+        }
     }
     if (config.languages?.includes('typescript')) {
         extensions.add('ts');
+        if (config.projectType === 'frontend') {
+            extensions.add('tsx');
+        }
     }
     if (config.languages?.includes('coffeescript')) {
         extensions.add('coffee');
+        if (config.projectType === 'frontend') {
+            extensions.add('cjsx');
+        }
     }
     // 默认为js（如果没有检测到语言）
     if (extensions.size === 0) {
         extensions.add('js');
+        if (config.projectType === 'frontend') {
+            extensions.add('jsx');
+        }
     }
     // 生成基础模式集合
     const basePatterns = new Set();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ai-worktool",
   "displayName": "吃豆豆:单测智能体",
-  "version": "1.0.69",
+  "version": "1.0.71",
   "description": "单元测试智能体,帮你开发单元测试用例代码直到100%单测覆盖通过。",
   "author": "jianguoke.cn",
   "license": "MIT",
@@ -28,11 +28,11 @@
     "createup": "node ./uposs.js create-local-folder",
     "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
     "puball": "yarn ver && yarn exepack && yarn vspack && yarn pubvs && yarn pubovsx && yarn puboss && yarn pubnpm",
-    "exepack": "yarn createup && cross-env PKG_CACHE_PATH=./binaries pkg -o packages/aicoder-1.0.69 . && yarn upicon",
+    "exepack": "yarn createup && cross-env PKG_CACHE_PATH=./binaries pkg -o packages/aicoder-1.0.71 . && yarn upicon",
     "pubvs": "yarn remove-deps && yarn changelog && vsce publish --yarn --baseContentUrl https://aicoder.jianguoke.cn/assets && yarn restore-deps",
     "pubovsx": "yarn remove-deps && ovsx publish -p 47621ff6-be56-4814-865e-d2a8e8a76f86 --yarn --baseContentUrl https://aicoder.jianguoke.cn/assets && yarn restore-deps",
     "patch": "yarn remove-deps && vsce publish patch --yarn && yarn restore-deps",
-    "vspack": "yarn createup && yarn remove-deps && vsce package -o packages/aicoder-1.0.69.vsix --yarn --baseContentUrl https://aicoder.jianguoke.cn/assets && yarn restore-deps",
+    "vspack": "yarn createup && yarn remove-deps && vsce package -o packages/aicoder-1.0.71.vsix --yarn --baseContentUrl https://aicoder.jianguoke.cn/assets && yarn restore-deps",
     "puboss": "node ./uposs.js upload",
     "pubnpm": "npm publish --registry=https://registry.npmjs.org",
     "prepare": "husky"