npm - ai-worktool - Versions diffs - 1.0.7 - Mend

ai-worktool 1.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/CHANGELOG.md +169 -0
package/LICENSE.txt +1 -0
package/README.md +67 -0
package/dist/agents/chanjet.js +377 -0
package/dist/agents/index.js +73 -0
package/dist/agents/jianguoke.js +182 -0
package/dist/agents/prompt.js +41 -0
package/dist/agents/toolCall.js +135 -0
package/dist/cli.js +9 -0
package/dist/loging.js +110 -0
package/dist/program.js +35 -0
package/dist/testAgent.js +142 -0
package/dist/tools/file.js +543 -0
package/dist/tools/git.js +204 -0
package/dist/tools/index.js +71 -0
package/dist/tools/interface.js +3 -0
package/dist/tools/javascript.js +180 -0
package/dist/tools/jest.js +482 -0
package/dist/tools/mocha.js +107 -0
package/dist/tools/package.js +376 -0
package/dist/tools/project.js +541 -0
package/dist/tools/typescript.js +242 -0
package/dist/tools/vitest.js +115 -0
package/dist/user.js +472 -0
package/dist/view.js +216 -0
package/package.json +289 -0

package/dist/user.js ADDED Viewed

@@ -0,0 +1,472 @@
+"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.setEnvironment = setEnvironment;
+exports.getEnvironment = getEnvironment;
+exports.setTokenStorage = setTokenStorage;
+exports.getTokenStorage = getTokenStorage;
+exports.openExternalUrl = openExternalUrl;
+exports.login = login;
+exports.cancelLogin = cancelLogin;
+exports.logout = logout;
+exports.isLoggedIn = isLoggedIn;
+exports.getUserData = getUserData;
+exports.decodeJwt = decodeJwt;
+exports.isJwtExpired = isJwtExpired;
+const http = __importStar(require("http"));
+const url_1 = require("url");
+const crypto_1 = __importDefault(require("crypto"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const util_1 = __importDefault(require("util"));
+const child_process_1 = require("child_process");
+// 转换exec为Promise形式，便于async/await使用
+const execAsync = util_1.default.promisify(child_process_1.exec);
+let tokenStorage;
+let environment;
+function setEnvironment(env) {
+    environment = env;
+}
+function getEnvironment() {
+    return environment;
+}
+function setTokenStorage(storage) {
+    tokenStorage = storage;
+}
+function getTokenStorage() {
+    return tokenStorage;
+}
+// 生成随机字符串用于CSRF保护
+function generateState() {
+    return crypto_1.default.randomBytes(16).toString('hex');
+}
+let lastLoginServer = null;
+let lastReject = null;
+/**
+ * 启动临时HTTP服务器接收登录回调
+ * @param state 用于验证的state值
+ * @returns 包含token的Promise
+ */
+function startCallbackServer(state, port) {
+    return new Promise((resolve, reject) => {
+        lastReject = reject;
+        const server = (lastLoginServer = http.createServer((req, res) => {
+            if (!req.url) {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end('Bad Request');
+                return;
+            }
+            const parsedUrl = new url_1.URL(req.url, `http://${req.headers.host}`);
+            const callbackState = parsedUrl.searchParams.get('state');
+            const token = parsedUrl.searchParams.get('token');
+            // 验证state防止CSRF攻击
+            if (callbackState !== state) {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                res.writeHead(403, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(`
+                    <html>
+                        <head>
+                            <style>
+                                body {
+                                    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                                    display: flex;
+                                    flex-direction: column;
+                                    align-items: center;
+                                    justify-content: center;
+                                    height: 100vh;
+                                    margin: 0;
+                                    background-color: #f8f9fa;
+                                    color: #333;
+                                }
+                                .card {
+                                    background-color: white;
+                                    border-radius: 12px;
+                                    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                                    padding: 2rem;
+                                    text-align: center;
+                                    max-width: 400px;
+                                    width: 90%;
+                                    border-left: 4px solid #dc3545;
+                                }
+                                h1 {
+                                    color: #dc3545;
+                                    margin-bottom: 1rem;
+                                    font-size: 1.8rem;
+                                }
+                                p {
+                                    margin: 0.5rem 0;
+                                    color: #6c757d;
+                                }
+                                .countdown {
+                                    font-weight: bold;
+                                    color: #dc3545;
+                                    font-size: 1.2rem;
+                                }
+                            </style>
+                        </head>
+                        <body>
+                            <div class="card">
+                                <h1>登录验证失败</h1>
+                                <p>无效的状态参数，可能存在安全风险</p>
+                            </div>
+                        </body>
+                    </html>
+                `);
+                reject(new Error('登录验证失败：无效的状态参数'));
+                server.close();
+                return;
+            }
+            // 处理token
+            if (token) {
+                // 构建清理后的URL（移除token和state参数）
+                parsedUrl.searchParams.delete('token');
+                parsedUrl.searchParams.delete('state');
+                const cleanUrl = parsedUrl.toString();
+                // 返回包含自动刷新和关闭逻辑的HTML
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(`
+                    <html>
+                        <head>
+                            <title>登录成功</title>
+                            <style>
+                                body {
+                                    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                                    display: flex;
+                                    flex-direction: column;
+                                    align-items: center;
+                                    justify-content: center;
+                                    height: 100vh;
+                                    margin: 0;
+                                    background-color: #f8f9fa;
+                                    color: #333;
+                                }
+                                .card {
+                                    background-color: white;
+                                    border-radius: 12px;
+                                    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                                    padding: 2rem;
+                                    text-align: center;
+                                    max-width: 400px;
+                                    width: 90%;
+                                    border-left: 4px solid #28a745;
+                                }
+                                h1 {
+                                    color: #28a745;
+                                    margin-bottom: 1rem;
+                                    font-size: 1.8rem;
+                                }
+                                p {
+                                    margin: 0.5rem 0;
+                                    color: #6c757d;
+                                }
+                                .countdown {
+                                    font-weight: bold;
+                                    color: #28a745;
+                                    font-size: 1.2rem;
+                                }
+                                .checkmark {
+                                    font-size: 3rem;
+                                    color: #28a745;
+                                    margin-bottom: 1rem;
+                                }
+                            </style>
+                        </head>
+                        <body>
+                            <div class="card">
+                                <div class="checkmark">✓</div>
+                                <h1>登录成功！</h1>
+                                <p>您可以关闭此窗口返回应用。</p>
+                            </div>
+                        </body>
+                    </html>
+                `);
+                resolve(token);
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(`
+                    <html>
+                        <head>
+                            <style>
+                                body {
+                                    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                                    display: flex;
+                                    flex-direction: column;
+                                    align-items: center;
+                                    justify-content: center;
+                                    height: 100vh;
+                                    margin: 0;
+                                    background-color: #f8f9fa;
+                                    color: #333;
+                                }
+                                .card {
+                                    background-color: white;
+                                    border-radius: 12px;
+                                    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                                    padding: 2rem;
+                                    text-align: center;
+                                    max-width: 400px;
+                                    width: 90%;
+                                    border-left: 4px solid #dc3545;
+                                }
+                                h1 {
+                                    color: #dc3545;
+                                    margin-bottom: 1rem;
+                                    font-size: 1.8rem;
+                                }
+                                p {
+                                    margin: 0.5rem 0;
+                                    color: #6c757d;
+                                }
+                                .countdown {
+                                    font-weight: bold;
+                                    color: #dc3545;
+                                    font-size: 1.2rem;
+                                }
+                                .error-icon {
+                                    font-size: 3rem;
+                                    color: #dc3545;
+                                    margin-bottom: 1rem;
+                                }
+                            </style>
+                        </head>
+                        <body>
+                            <div class="card">
+                                <div class="error-icon">✗</div>
+                                <h1>登录失败</h1>
+                                <p>未收到有效的认证信息</p>
+                            </div>
+                        </body>
+                    </html>
+                `);
+                reject(new Error('登录失败：未收到token'));
+            }
+            server.close();
+        }));
+        // 监听随机可用端口
+        server.listen(port, 'localhost', () => {
+            const address = server.address();
+            if (typeof address === 'object' && address) {
+                console.log(`回调服务器启动在端口 ${address.port}`);
+            }
+        });
+        // 设置超时（5分钟）
+        setTimeout(() => {
+            server.close();
+            reject(new Error('登录超时，请重试'));
+        }, 5 * 60 * 1000);
+    });
+}
+/**
+ * 获取可用端口
+ * @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('无法获取可用端口'));
+            }
+        });
+    });
+}
+async function openExternalUrl(url) {
+    try {
+        // 根据不同操作系统，使用相应的命令打开浏览器
+        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;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('无法打开外部浏览器：', error);
+        return false;
+    }
+}
+/**
+ * 执行登录流程
+ * @param env 环境接口
+ * @param tokenStorage token存储接口
+ * @param authServerUrl 认证服务器URL
+ * @param clientId 客户端ID
+ * @returns 登录成功后的token
+ */
+async function login(authServerUrl, clientId) {
+    const env = getEnvironment();
+    const tokenStorage = getTokenStorage();
+    const state = generateState();
+    const port = await getAvailablePort();
+    const callbackUrl = `http://localhost:${port}/callback`;
+    await cancelLogin();
+    // 启动回调服务器
+    const serverPromise = startCallbackServer(state, port);
+    // 构建认证服务器URL
+    const authUrl = new url_1.URL(authServerUrl);
+    authUrl.searchParams.set('clientId', clientId);
+    authUrl.searchParams.set('redirectUrl', callbackUrl);
+    authUrl.searchParams.set('state', state);
+    authUrl.searchParams.set('responseType', 'token');
+    // 打开外部登录页面
+    const opened = await openExternalUrl(authUrl.toString());
+    if (!opened) {
+        throw new Error('无法打开外部浏览器进行登录');
+    }
+    // 等待回调返回token
+    const token = await serverPromise;
+    // 存储token
+    await tokenStorage.set(token);
+    env.showInfoMessage('登录成功！');
+    return token;
+}
+async function cancelLogin() {
+    if (lastLoginServer) {
+        lastLoginServer.close();
+        lastLoginServer = null;
+    }
+    if (lastReject) {
+        lastReject(new Error('登录已取消'));
+        lastReject = null;
+    }
+}
+/**
+ * 执行登出操作
+ * @param tokenStorage token存储接口
+ * @param env 环境接口
+ */
+async function logout() {
+    const env = getEnvironment();
+    const tokenStorage = getTokenStorage();
+    await tokenStorage.clear();
+    env.showInfoMessage('已成功登出');
+}
+/**
+ * 检查用户是否已登录
+ * @param tokenStorage token存储接口
+ * @returns 是否已登录
+ */
+function isLoggedIn() {
+    const tokenStorage = getTokenStorage();
+    const token = tokenStorage.get();
+    if (!token) {
+        return false;
+    }
+    if (isJwtExpired(token)) {
+        return false;
+    }
+    return true;
+}
+function getUserData() {
+    const token = getTokenStorage().get();
+    if (!token) {
+        return null;
+    }
+    try {
+        const decoded = decodeJwt(token);
+        return decoded;
+    }
+    catch (error) {
+        console.error('解析用户数据失败:', error);
+    }
+    return null;
+}
+/**
+ * 解析JWT获取其中的信息
+ * @param token JWT字符串
+ * @returns 解析后的payload对象
+ */
+function decodeJwt(token) {
+    try {
+        // 不验证签名，仅解码获取信息
+        const decoded = jsonwebtoken_1.default.decode(token);
+        return decoded;
+    }
+    catch (error) {
+        console.error('JWT解码失败:', error);
+        return null;
+    }
+}
+/**
+ * 验证JWT是否过期
+ * @param token JWT字符串 或 已解析的JWT payload
+ * @returns 如果过期返回true，否则返回false
+ */
+function isJwtExpired(token) {
+    try {
+        let payload;
+        // 如果传入的是字符串，则先解析
+        if (typeof token === 'string') {
+            payload = decodeJwt(token);
+            if (!payload) {
+                return true;
+            } // 解析失败视为过期
+        }
+        else {
+            payload = token;
+        }
+        // 检查是否包含过期时间
+        if (!payload.exp) {
+            return false;
+        } // 没有过期时间，视为不过期
+        // 计算当前时间（秒级时间戳）
+        const currentTime = Math.floor(Date.now() / 1000);
+        // 比较当前时间和过期时间
+        return currentTime > payload.exp;
+    }
+    catch (error) {
+        console.error('JWT过期检查失败:', error);
+        return true; // 发生错误时视为过期
+    }
+}
+//# sourceMappingURL=user.js.map

package/dist/view.js ADDED Viewed

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COVERAGE_FILE_PATH = void 0;
+exports.showCoverageView = showCoverageView;
+exports.stopMonitoring = stopMonitoring;
+exports.loadAndDisplayCoverage = loadAndDisplayCoverage;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const table_1 = require("table");
+const chalk_1 = __importDefault(require("chalk"));
+let REFRESH_INTERVAL = 3000;
+// 存储上一次的覆盖率数据
+let previousCoverage = null;
+// 存储变化的单元格位置
+let changedCells = [];
+// 文件监听对象
+let fileWatcher = null;
+// 定时器ID
+let refreshTimer = null;
+const output = console.log;
+exports.COVERAGE_FILE_PATH = 'coverage-summary.json';
+// 主函数
+async function showCoverageView(rootDir, coverageFilePath = exports.COVERAGE_FILE_PATH) {
+    const coveragePath = path_1.default.join(rootDir, coverageFilePath);
+    console.log(chalk_1.default.cyan('开始监控覆盖率数据...' + coveragePath));
+    // 初始加载
+    await loadAndDisplayCoverage(coveragePath);
+    // 设置文件监听
+    fileWatcher = fs_1.default.watch(coveragePath, async (eventType, filename) => {
+        if (filename && eventType === 'change') {
+            await loadAndDisplayCoverage(coveragePath);
+        }
+    });
+    // 定时刷新，确保捕获所有变化
+    // refreshTimer = setInterval(() => loadAndDisplayCoverage(coveragePath), refershTime) as any;
+}
+// 停止监控函数
+function stopMonitoring() {
+    // 清理文件监听器
+    if (fileWatcher) {
+        fileWatcher.close();
+        fileWatcher = null;
+    }
+    // 清理定时器
+    if (refreshTimer) {
+        clearInterval(refreshTimer);
+        refreshTimer = null;
+    }
+}
+// 加载并显示覆盖率数据
+async function loadAndDisplayCoverage(coveragePath, refreshTimeout = REFRESH_INTERVAL) {
+    try {
+        const coverage = await readCoverageFile(coveragePath);
+        // 生成表格数据
+        const tableData = generateTableData(coverage);
+        // 比较并标记变化
+        if (previousCoverage && refreshTimeout > 0) {
+            changedCells = compareCoverage(previousCoverage, coverage);
+            // 如果有变化，3秒后清除标记
+            if (changedCells.length > 0) {
+                setTimeout(() => {
+                    changedCells = [];
+                    loadAndDisplayCoverage(coveragePath);
+                }, refreshTimeout);
+            }
+        }
+        // 存储当前覆盖率数据供下次比较
+        previousCoverage = coverage;
+        // 渲染表格
+        renderTable(tableData);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`加载覆盖率数据时出错: ${error.message}`));
+    }
+}
+// 读取覆盖率文件
+async function readCoverageFile(coveragePath) {
+    return new Promise((resolve, reject) => {
+        fs_1.default.readFile(coveragePath, 'utf8', (err, data) => {
+            if (err) {
+                reject(new Error(`无法读取覆盖率文件: ${err.message}`));
+                return;
+            }
+            try {
+                const coverage = JSON.parse(data);
+                resolve(coverage);
+            }
+            catch (parseError) {
+                reject(new Error(`解析覆盖率文件失败: ${parseError.message}`));
+            }
+        });
+    });
+}
+// 生成表格数据
+function generateTableData(coverage) {
+    const tableData = [['文件路径', '行覆盖率(%)', '语句覆盖率(%)', '函数覆盖率(%)', '分支覆盖率(%)']];
+    // 提取并排序文件路径
+    const filePaths = Object.keys(coverage).filter((key) => key !== 'total');
+    filePaths.sort();
+    // 添加总计行
+    tableData.push([
+        chalk_1.default.bold('总计'),
+        formatPercentage(coverage.total.lines.pct),
+        formatPercentage(coverage.total.statements.pct),
+        formatPercentage(coverage.total.functions.pct),
+        formatPercentage(coverage.total.branches.pct)
+    ]);
+    // 添加分隔线
+    tableData.push(['---', '---', '---', '---', '---']);
+    // 添加每个文件的覆盖率数据
+    filePaths.forEach((filePath) => {
+        const fileCoverage = coverage[filePath];
+        tableData.push([
+            path_1.default.basename(filePath),
+            formatPercentage(fileCoverage.lines.pct),
+            formatPercentage(fileCoverage.statements.pct),
+            formatPercentage(fileCoverage.functions.pct),
+            formatPercentage(fileCoverage.branches.pct)
+        ]);
+    });
+    return tableData;
+}
+// 格式化百分比并应用颜色
+function formatPercentage(pct) {
+    if (pct === 'Unknown')
+        return chalk_1.default.gray('Unknown');
+    let formatted = pct.toFixed(2) + '%';
+    // 根据覆盖率设置颜色
+    if (pct < 50) {
+        formatted = chalk_1.default.red(formatted);
+    }
+    else if (pct < 80) {
+        formatted = chalk_1.default.yellow(formatted);
+    }
+    else {
+        formatted = chalk_1.default.green(formatted);
+    }
+    return formatted;
+}
+// 比较覆盖率数据，找出变化的单元格
+function compareCoverage(oldData, newData) {
+    const changes = [];
+    // 比较总计
+    const compareMetrics = (oldMetrics, newMetrics, rowIndex) => {
+        if (oldMetrics.lines.pct !== newMetrics.lines.pct) {
+            changes.push([rowIndex, 1]);
+        }
+        if (oldMetrics.statements.pct !== newMetrics.statements.pct) {
+            changes.push([rowIndex, 2]);
+        }
+        if (oldMetrics.functions.pct !== newMetrics.functions.pct) {
+            changes.push([rowIndex, 3]);
+        }
+        if (oldMetrics.branches.pct !== newMetrics.branches.pct) {
+            changes.push([rowIndex, 4]);
+        }
+    };
+    // 比较总计行
+    compareMetrics(oldData.total, newData.total, 1);
+    // 比较文件行
+    const filePaths = Object.keys(oldData).filter((key) => key !== 'total');
+    filePaths.forEach((filePath, index) => {
+        if (newData[filePath]) {
+            compareMetrics(oldData[filePath], newData[filePath], index + 3);
+        }
+    });
+    return changes;
+}
+// 渲染表格
+function renderTable(tableData) {
+    // 应用变化标记
+    const markedData = tableData.map((row, rowIndex) => {
+        return row.map((cell, colIndex) => {
+            // 检查是否是变化的单元格
+            if (changedCells.some(([r, c]) => r === rowIndex && c === colIndex)) {
+                return chalk_1.default.bgRed.white(cell);
+            }
+            return cell;
+        });
+    });
+    // 配置表格样式
+    const tableConfig = {
+        columns: {
+            0: { width: 30 },
+            1: { width: 15, alignment: 'right' },
+            2: { width: 15, alignment: 'right' },
+            3: { width: 15, alignment: 'right' },
+            4: { width: 15, alignment: 'right' }
+        },
+        border: {
+            topBody: `─`,
+            topJoin: `┬`,
+            topLeft: `┌`,
+            topRight: `┐`,
+            bottomBody: `─`,
+            bottomJoin: `┴`,
+            bottomLeft: `└`,
+            bottomRight: `┘`,
+            bodyLeft: `│`,
+            bodyRight: `│`,
+            bodyJoin: `│`,
+            joinBody: `─`,
+            joinLeft: `├`,
+            joinRight: `┤`,
+            joinJoin: `┼`
+        }
+    };
+    // 清除控制台并打印表格
+    console.clear();
+    console.log(chalk_1.default.cyan('单测覆盖率监控工具 - 最后更新: ' + new Date().toLocaleString()));
+    output((0, table_1.table)(markedData, tableConfig));
+}
+//# sourceMappingURL=view.js.map