@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/coder-harness/src/plugins/code-check-manager.js

@@ -0,0 +1,238 @@
+/**
+ * @fileoverview CodeCheckManager - 外部命令检查管理器
+ *
+ * 管理多语言的外部命令检查（Linter + TypeCheck）
+ */
+import { spawn } from "child_process";
+import path from "path";
+/**
+ * 内置命令映射表
+ */
+const DEFAULT_COMMANDS = {
+    ".ts": "tsc --noEmit --pretty false {file}",
+    ".tsx": "tsc --noEmit --pretty false {file}",
+    ".mts": "tsc --noEmit --pretty false {file}",
+    ".cts": "tsc --noEmit --pretty false {file}",
+    ".js": "tsc --noEmit --pretty false {file}",
+    ".jsx": "tsc --noEmit --pretty false {file}",
+    ".mjs": "tsc --noEmit --pretty false {file}",
+    ".cjs": "tsc --noEmit --pretty false {file}",
+    ".py": "mypy --no-error-summary {file}",
+    ".rs": "rustc --edition 2021 --emit=metadata {file} 2>&1",
+    ".go": "go vet {file}",
+    ".json": "cat {file} | jq . > /dev/null",
+    ".yaml": "cat {file} | yq . > /dev/null",
+    ".yml": "cat {file} | yq . > /dev/null",
+};
+/**
+ * TypeScript 解析器
+ */
+const TSC_PARSER = {
+    parse(output, filePath) {
+        const issues = [];
+        const regex = /^(.+?)\((\d+),(\d+)\):\s+(error|warning|info)\s+(TS\d+)?:\s*(.+)$/gm;
+        let match;
+        while ((match = regex.exec(output)) !== null) {
+            issues.push({
+                line: parseInt(match[2], 10) - 1,
+                column: parseInt(match[3], 10) - 1,
+                message: match[6],
+                code: match[5],
+                severity: match[4],
+                command: `tsc --noEmit`,
+            });
+        }
+        return issues;
+    },
+};
+/**
+ * mypy 解析器
+ */
+const MYPY_PARSER = {
+    parse(output, filePath) {
+        const issues = [];
+        const regex = /^(.+?):(\d+):\s+(error|warning|note):\s*(.+)$/gm;
+        let match;
+        while ((match = regex.exec(output)) !== null) {
+            issues.push({
+                line: parseInt(match[2], 10) - 1,
+                column: 0,
+                message: match[4],
+                severity: match[3],
+                command: `mypy`,
+            });
+        }
+        return issues;
+    },
+};
+/**
+ * JSON/YAML 解析器
+ */
+const JSON_PARSER = {
+    parse(output, filePath) {
+        const issues = [];
+        if (output.includes("parse error") || output.includes("invalid")) {
+            issues.push({
+                line: 0,
+                column: 0,
+                message: output.split("\n")[0] || "Parse error",
+                severity: "error",
+                command: "jq/yq",
+            });
+        }
+        return issues;
+    },
+};
+/**
+ * 命令解析器映射
+ */
+const PARSERS = {
+    ".ts": TSC_PARSER,
+    ".tsx": TSC_PARSER,
+    ".mts": TSC_PARSER,
+    ".cts": TSC_PARSER,
+    ".js": TSC_PARSER,
+    ".jsx": TSC_PARSER,
+    ".mjs": TSC_PARSER,
+    ".cjs": TSC_PARSER,
+    ".py": MYPY_PARSER,
+    ".json": JSON_PARSER,
+    ".yaml": JSON_PARSER,
+    ".yml": JSON_PARSER,
+};
+export class CodeCheckManager {
+    config;
+    cache;
+    constructor(config) {
+        this.config = config;
+        this.cache = new Map();
+    }
+    /**
+     * 获取文件对应的检查命令
+     */
+    getCommand(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        // 优先使用自定义命令
+        if (this.config.commands?.[ext]) {
+            return this.config.commands[ext];
+        }
+        // 使用默认命令
+        return DEFAULT_COMMANDS[ext] || null;
+    }
+    /**
+     * 检查单个文件
+     */
+    async checkFile(filePath) {
+        const command = this.getCommand(filePath);
+        if (!command) {
+            const result = {
+                filePath,
+                output: "",
+                exitCode: 0,
+                success: true,
+                issues: [],
+                timestamp: Date.now(),
+            };
+            this.cache.set(filePath, result);
+            return result;
+        }
+        // 替换 {file} 占位符
+        const cmdTemplate = command.replace("{file}", filePath);
+        const [cmd, ...args] = cmdTemplate.split(" ");
+        return new Promise((resolve) => {
+            const proc = spawn(cmd, args.filter(Boolean), {
+                cwd: path.dirname(filePath),
+                stdio: ["pipe", "pipe", "pipe"],
+                shell: false,
+            });
+            const timeoutId = setTimeout(() => {
+                proc.kill();
+                resolve({
+                    filePath,
+                    output: "Command timed out",
+                    exitCode: -1,
+                    success: false,
+                    issues: [{
+                            line: 0,
+                            column: 0,
+                            message: `Command timed out after ${this.config.timeout}ms`,
+                            severity: "error",
+                            command: cmdTemplate,
+                        }],
+                    timestamp: Date.now(),
+                });
+            }, this.config.timeout);
+            let stdout = "";
+            let stderr = "";
+            proc.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+            proc.on("error", (err) => {
+                clearTimeout(timeoutId);
+                resolve({
+                    filePath,
+                    output: err.message,
+                    exitCode: -1,
+                    success: false,
+                    issues: [{
+                            line: 0,
+                            column: 0,
+                            message: `Command not found: ${cmd}`,
+                            severity: "error",
+                            command: cmdTemplate,
+                        }],
+                    timestamp: Date.now(),
+                });
+            });
+            proc.on("close", (code) => {
+                clearTimeout(timeoutId);
+                const output = stdout + (stderr ? "\n" + stderr : "");
+                const ext = path.extname(filePath).toLowerCase();
+                const parser = PARSERS[ext] || TSC_PARSER;
+                const issues = parser.parse(output, filePath);
+                const result = {
+                    filePath,
+                    output,
+                    exitCode: code ?? 0,
+                    success: (code ?? 0) === 0,
+                    issues,
+                    timestamp: Date.now(),
+                };
+                this.cache.set(filePath, result);
+                resolve(result);
+            });
+        });
+    }
+    /**
+     * 获取缓存结果
+     */
+    getCached(filePath) {
+        return this.cache.get(filePath);
+    }
+    /**
+     * 清除缓存
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * 释放资源
+     */
+    dispose() {
+        this.cache.clear();
+    }
+}
+/**
+ * 创建 CodeCheckManager 实例
+ */
+export function createCodeCheckManager(config) {
+    return new CodeCheckManager({
+        timeout: config?.timeout ?? 30000,
+        ignorePatterns: config?.ignorePatterns ?? [],
+        commands: config?.commands,
+    });
+}
+//# sourceMappingURL=code-check-manager.js.map

package/dist/coder-harness/src/plugins/code-check-manager.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=code-check-manager.test.d.ts.map

package/dist/coder-harness/src/plugins/code-check-manager.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+import { createCodeCheckManager } from "./code-check-manager.js";
+describe("CodeCheckManager", () => {
+    describe("getCommand", () => {
+        it("should return default command for TypeScript files", () => {
+            const manager = createCodeCheckManager({});
+            const cmd = manager.getCommand("test.ts");
+            expect(cmd).toContain("tsc --noEmit");
+        });
+        it("should return null for unsupported extensions", () => {
+            const manager = createCodeCheckManager({});
+            const cmd = manager.getCommand("test.txt");
+            expect(cmd).toBeNull();
+        });
+        it("should use custom command when provided", () => {
+            const manager = createCodeCheckManager({
+                commands: { ".ts": "custom-tsc {file}" },
+            });
+            const cmd = manager.getCommand("test.ts");
+            expect(cmd).toBe("custom-tsc {file}");
+        });
+    });
+    describe("checkFile", () => {
+        it("should return empty result for unsupported files", async () => {
+            const manager = createCodeCheckManager({});
+            const result = await manager.checkFile("test.txt");
+            expect(result.success).toBe(true);
+            expect(result.issues).toHaveLength(0);
+        });
+    });
+    describe("cache", () => {
+        it("should cache results", async () => {
+            const manager = createCodeCheckManager({});
+            await manager.checkFile("test.txt");
+            const cached = manager.getCached("test.txt");
+            expect(cached).toBeDefined();
+        });
+        it("should clear cache", () => {
+            const manager = createCodeCheckManager({});
+            manager.clearCache();
+            expect(manager.getCached("test.txt")).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=code-check-manager.test.js.map

package/dist/coder-harness/src/plugins/code-check-plugin.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview CodeCheckPlugin - 外部命令检查插件
+ *
+ * 在文件写入或编辑后执行外部命令进行强制检查
+ */
+import type { CodeCheckPluginConfig } from "../types/linter";
+import type { ToolHookContext } from "@ai-setting/roy-agent-core";
+/**
+ * CodeCheckPlugin Hook 数据类型
+ */
+export interface CodeCheckHookData {
+    toolName: string;
+    args: Record<string, unknown>;
+    result: {
+        success: boolean;
+        output?: string | Record<string, unknown>;
+        error?: string;
+        metadata?: Record<string, unknown>;
+    };
+}
+/**
+ * CodeCheckPlugin
+ *
+ * 通过 after.tool hook 在文件写入或编辑后执行外部命令检查
+ */
+export declare class CodeCheckPlugin {
+    private codeCheckManager;
+    private config;
+    private ignorePatterns;
+    private supportedExtensions;
+    constructor(config?: CodeCheckPluginConfig);
+    get name(): string;
+    get description(): string;
+    get priority(): number;
+    /**
+     * 获取 Hook 点
+     */
+    getHookPoint(): "tool:after.execute";
+    /**
+     * 执行 Hook
+     *
+     * ctx 可以是两种格式：
+     * 1. 直接传入 ToolHookContext（测试场景）
+     * 2. HookManager 包装的 HookContext<ToolHookContext>（实际运行场景）
+     *    - ctx.data 包含 { tool, args, context, result }
+     */
+    onAfterTool(ctx: ToolHookContext | {
+        data: ToolHookContext;
+    }): Promise<void>;
+    /**
+     * 获取目标文件路径
+     */
+    getTargetFilePath(toolName: string, args: Record<string, unknown>): string | null;
+    /**
+     * 检查是否支持
+     */
+    isSupported(filePath: string): boolean;
+    /**
+     * 检查是否忽略
+     */
+    shouldIgnore(filePath: string): boolean;
+    /**
+     * 将结果附加到 tool result
+     */
+    private attachToResult;
+    /**
+     * 格式化检查结果
+     */
+    private formatCodeCheckResult;
+    /**
+     * 释放资源
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * 创建 CodeCheckPlugin 实例
+ */
+export declare function createCodeCheckPlugin(config?: CodeCheckPluginConfig): CodeCheckPlugin;
+//# sourceMappingURL=code-check-plugin.d.ts.map

package/dist/coder-harness/src/plugins/code-check-plugin.js

@@ -0,0 +1,181 @@
+/**
+ * @fileoverview CodeCheckPlugin - 外部命令检查插件
+ *
+ * 在文件写入或编辑后执行外部命令进行强制检查
+ */
+import { createCodeCheckManager } from "./code-check-manager.js";
+import { shouldIgnore } from "../util/glob.js";
+/**
+ * CodeCheckPlugin
+ *
+ * 通过 after.tool hook 在文件写入或编辑后执行外部命令检查
+ */
+export class CodeCheckPlugin {
+    codeCheckManager;
+    config;
+    ignorePatterns;
+    supportedExtensions;
+    constructor(config = {}) {
+        this.config = config;
+        this.ignorePatterns = config.ignorePatterns ?? [];
+        this.supportedExtensions = new Set(config.supportedExtensions ?? [
+            ".ts", ".tsx", ".mts", ".cts",
+            ".js", ".jsx", ".mjs", ".cjs",
+            ".py", ".rs", ".go", ".json",
+            ".yaml", ".yml",
+        ]);
+        this.codeCheckManager = createCodeCheckManager({
+            timeout: config.timeout ?? 30000,
+            ignorePatterns: this.ignorePatterns,
+            commands: config.commands,
+        });
+    }
+    get name() {
+        return "CodeCheckPlugin";
+    }
+    get description() {
+        return "External command code checking (linter + type check)";
+    }
+    get priority() {
+        return 90; // 在 LSPPlugin 之后执行
+    }
+    /**
+     * 获取 Hook 点
+     */
+    getHookPoint() {
+        return "tool:after.execute";
+    }
+    /**
+     * 执行 Hook
+     *
+     * ctx 可以是两种格式：
+     * 1. 直接传入 ToolHookContext（测试场景）
+     * 2. HookManager 包装的 HookContext<ToolHookContext>（实际运行场景）
+     *    - ctx.data 包含 { tool, args, context, result }
+     */
+    async onAfterTool(ctx) {
+        // 兼容两种格式：直接传入 ToolHookContext 或包装在 HookContext.data 中
+        const data = "data" in ctx ? ctx.data : ctx;
+        const toolName = typeof data.tool === "string" ? data.tool : data.tool?.name || "";
+        const args = data.args || {};
+        const result = data.result;
+        // 检查是否启用
+        if (this.config.enabled === false) {
+            return;
+        }
+        // 只处理 write_file 和 edit_file
+        if (toolName !== "write_file" && toolName !== "edit_file") {
+            return;
+        }
+        // 检查配置
+        if (toolName === "write_file" && this.config.checkOnSave === false) {
+            return;
+        }
+        if (toolName === "edit_file" && this.config.checkOnEdit === false) {
+            return;
+        }
+        // 获取目标文件路径
+        const filePath = this.getTargetFilePath(toolName, args);
+        if (!filePath) {
+            return;
+        }
+        // 检查是否支持该文件类型
+        if (!this.isSupported(filePath)) {
+            return;
+        }
+        // 检查忽略模式
+        if (this.shouldIgnore(filePath)) {
+            return;
+        }
+        // 执行检查
+        try {
+            const checkResult = await this.codeCheckManager.checkFile(filePath);
+            // 只在有错误或警告时附加结果
+            const hasIssues = checkResult.issues.some((i) => i.severity === "error" || i.severity === "warning");
+            if (hasIssues && result) {
+                this.attachToResult(result, checkResult);
+            }
+        }
+        catch (error) {
+            console.warn(`CodeCheckPlugin: check failed for ${filePath}:`, error);
+        }
+    }
+    /**
+     * 获取目标文件路径
+     */
+    getTargetFilePath(toolName, args) {
+        if (typeof args.path === "string") {
+            return args.path;
+        }
+        if (typeof args.filePath === "string") {
+            return args.filePath;
+        }
+        return null;
+    }
+    /**
+     * 检查是否支持
+     */
+    isSupported(filePath) {
+        const ext = filePath.substring(filePath.lastIndexOf(".")).toLowerCase();
+        return this.supportedExtensions.has(ext);
+    }
+    /**
+     * 检查是否忽略
+     */
+    shouldIgnore(filePath) {
+        return shouldIgnore(filePath, this.ignorePatterns);
+    }
+    /**
+     * 将结果附加到 tool result
+     */
+    attachToResult(result, checkResult) {
+        const formattedOutput = this.formatCodeCheckResult(checkResult);
+        if (typeof result.output === "string") {
+            result.output = result.output + "\n\n" + formattedOutput;
+        }
+        else if (typeof result.output === "object") {
+            result.output = {
+                ...result.output,
+                codeCheck: {
+                    issues: checkResult.issues,
+                    output: checkResult.output,
+                },
+                codeCheckText: formattedOutput,
+            };
+        }
+        else {
+            result.output = formattedOutput;
+        }
+    }
+    /**
+     * 格式化检查结果
+     */
+    formatCodeCheckResult(result) {
+        if (result.issues.length === 0) {
+            return "";
+        }
+        const lines = [];
+        lines.push("## Code Check Results");
+        lines.push(`Found ${result.issues.length} issue(s):\n`);
+        for (const issue of result.issues) {
+            const severity = issue.severity === "error" ? "Error" : issue.severity === "warning" ? "Warning" : "Info";
+            lines.push(`- **[${severity}]** ${issue.message}`);
+            lines.push(`  - Location: ${result.filePath}:${issue.line + 1}:${issue.column + 1}`);
+            lines.push(`  - Command: ${issue.command}`);
+        }
+        return lines.join("\n");
+    }
+    /**
+     * 释放资源
+     */
+    async dispose() {
+        await this.codeCheckManager.dispose();
+    }
+}
+/**
+ * 创建 CodeCheckPlugin 实例
+ */
+export function createCodeCheckPlugin(config) {
+    return new CodeCheckPlugin(config);
+}
+//# sourceMappingURL=code-check-plugin.js.map

package/dist/coder-harness/src/plugins/code-check-plugin.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=code-check-plugin.test.d.ts.map

package/dist/coder-harness/src/plugins/code-check-plugin.test.js

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { CodeCheckPlugin } from "./code-check-plugin.js";
+describe("CodeCheckPlugin", () => {
+    let plugin;
+    beforeEach(() => {
+        plugin = new CodeCheckPlugin({});
+    });
+    describe("getTargetFilePath", () => {
+        it("should extract path from args.path", () => {
+            const path = plugin.getTargetFilePath("write_file", { path: "/tmp/test.ts" });
+            expect(path).toBe("/tmp/test.ts");
+        });
+        it("should extract path from args.filePath", () => {
+            const path = plugin.getTargetFilePath("edit_file", { filePath: "/tmp/test.ts" });
+            expect(path).toBe("/tmp/test.ts");
+        });
+        it("should return null when no path found", () => {
+            const path = plugin.getTargetFilePath("write_file", {});
+            expect(path).toBeNull();
+        });
+    });
+    describe("isSupported", () => {
+        it("should return true for TypeScript files", () => {
+            expect(plugin.isSupported("test.ts")).toBe(true);
+            expect(plugin.isSupported("test.tsx")).toBe(true);
+        });
+        it("should return true for Python files", () => {
+            expect(plugin.isSupported("test.py")).toBe(true);
+        });
+        it("should return false for unsupported files", () => {
+            expect(plugin.isSupported("test.txt")).toBe(false);
+            expect(plugin.isSupported("test.md")).toBe(false);
+        });
+    });
+    describe("onAfterTool", () => {
+        it("should skip non-write/edit tools (old format)", async () => {
+            const ctx = {
+                data: {
+                    toolName: "read_file",
+                    args: { path: "/tmp/test.ts" },
+                    result: { success: true, output: "" },
+                },
+            };
+            await plugin.onAfterTool(ctx);
+            expect(ctx.data.result.output).toBe("");
+        });
+        it("should skip non-write/edit tools (new format)", async () => {
+            const ctx = {
+                data: {
+                    tool: { name: "read_file" },
+                    args: { path: "/tmp/test.ts" },
+                    result: { success: true, output: "" },
+                },
+            };
+            await plugin.onAfterTool(ctx);
+            expect(ctx.data.result.output).toBe("");
+        });
+        it("should skip when disabled", async () => {
+            const disabledPlugin = new CodeCheckPlugin({ enabled: false });
+            const ctx = {
+                data: {
+                    tool: { name: "write_file" },
+                    args: { path: "/tmp/test.ts" },
+                    result: { success: true, output: "" },
+                },
+            };
+            await disabledPlugin.onAfterTool(ctx);
+            expect(ctx.data.result.output).toBe("");
+        });
+        it("should skip unsupported file types", async () => {
+            const ctx = {
+                data: {
+                    tool: { name: "write_file" },
+                    args: { path: "/tmp/test.txt" },
+                    result: { success: true, output: "" },
+                },
+            };
+            await plugin.onAfterTool(ctx);
+            expect(ctx.data.result.output).toBe("");
+        });
+        it("should skip when tool is string (new format)", async () => {
+            const ctx = {
+                data: {
+                    tool: "read_file",
+                    args: { path: "/tmp/test.ts" },
+                    result: { success: true, output: "" },
+                },
+            };
+            await plugin.onAfterTool(ctx);
+            expect(ctx.data.result.output).toBe("");
+        });
+    });
+});
+//# sourceMappingURL=code-check-plugin.test.js.map