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

package/dist/coder-harness/src/index.js

@@ -0,0 +1,36 @@
+/**
+ * @roy-agent/coder - Coder Harness
+ *
+ * Programming-focused Environment for roy-agent.
+ *
+ * Core Philosophy:
+ * - Core (@ai-setting/roy-agent-core) is scenario-agnostic
+ * - Coder Harness (@roy-agent/coder) extends core with programming-specific capabilities
+ *
+ * Instead of re-implementing tools, Coder Harness uses the Plugin mechanism
+ * to add programming features via Hooks.
+ */
+// Re-export core types for convenience
+export { BaseEnvironment } from "@ai-setting/roy-agent-core";
+// ============================================================================
+// LSP Module
+// ============================================================================
+export { LSPClient, createLSPClient } from "./lsp/client.js";
+export { LSPServer, LSPServerRegistry } from "./lsp/server.js";
+export { LSPManager, createGlobalLSPManager, globalLSPManager } from "./lsp/manager.js";
+export { getServerId, getLanguageId, isSupported, getExtensionsByServer, LANGUAGE_EXTENSIONS, SERVER_BY_EXTENSION, } from "./lsp/language-map.js";
+// ============================================================================
+// Plugins
+// ============================================================================
+export { LSPPlugin, createLSPPlugin } from "./plugins/lsp-plugin.js";
+// PluginHookAdapter
+export { PluginHookAdapter, createPluginHookAdapter, } from "./plugins/plugin-hook-adapter.js";
+// ReminderPlugin
+export { ReminderPlugin, createReminderPlugin, } from "./plugins/reminder-plugin.js";
+// Re-export DiagnosticSeverity enum
+export { DiagnosticSeverity } from "./types/linter.js";
+// ============================================================================
+// LSP Dependency Management
+// ============================================================================
+export { LSPDependencyInstaller, LSP_PACKAGES, createInstaller, LSPConfig, LSPConfigLoader, getDefaultLSPConfig, createLSPConfigLoader, } from "./lsp-deps/index.js";
+//# sourceMappingURL=index.js.map

package/dist/coder-harness/src/lsp/client.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview LSP Client 实现
+ *
+ * 使用 vscode-jsonrpc 与 LSP 服务器通信
+ */
+import { ChildProcess } from "child_process";
+import type { LSPServerInfo, Diagnostic } from "../types/linter";
+/**
+ * LSP Client
+ *
+ * 封装与 LSP 服务器的 JSON-RPC 通信
+ */
+export declare class LSPClient {
+    private connection;
+    private serverInfo;
+    private rootUri;
+    private pendingDiagnostics;
+    private openDocuments;
+    private lastUsed;
+    private disposed;
+    private process;
+    /** 诊断请求序列号（递增） */
+    private _requestIdCounter;
+    constructor(process: ChildProcess, serverInfo: LSPServerInfo, rootUri: string);
+    /**
+     * 分配新的请求序列号
+     */
+    private allocateRequestId;
+    /**
+     * 设置通知处理器
+     */
+    private setupNotificationHandlers;
+    /**
+     * 初始化 LSP 会话
+     */
+    initialize(): Promise<void>;
+    /**
+     * 文档版本号追踪
+     * 按 URI 索引，每次文档内容变化时递增
+     */
+    private documentVersions;
+    /**
+     * 诊断结果存储（带版本标记）
+     * 用于解决并发请求时的诊断同步问题
+     */
+    private diagnosticsWithVersion;
+    /**
+     * 活跃的请求追踪
+     * 用于确保每个请求只返回自己的诊断结果
+     */
+    private activeRequestId;
+    /**
+     * 打开文档
+     */
+    openDocument(filePath: string, text?: string): Promise<void>;
+    /**
+     * 获取诊断信息
+     *
+     * 使用请求序列号机制确保诊断同步：
+     * 1. 分配请求序列号
+     * 2. 设置为当前活跃请求
+     * 3. 发送 didChange 触发 LSP 服务器重新分析
+     * 4. 只返回与当前序列号匹配的诊断
+     */
+    getDiagnostics(filePath: string): Promise<Diagnostic[]>;
+    /**
+     * 转换诊断信息
+     */
+    private convertDiagnostic;
+    /**
+     * 获取服务器 ID
+     */
+    getServerId(): string;
+    /**
+     * 获取最后使用时间
+     */
+    getLastUsed(): number;
+    /**
+     * 健康检查 - ping 连接验证
+     *
+     * 通过发送 $/cancelRequest 或简单的方法调用来验证连接是否仍然活跃
+     * 如果服务器已崩溃，连接应该会失败
+     *
+     * @returns true 如果连接健康，false 如果连接已断开
+     */
+    ping(): Promise<boolean>;
+    /**
+     * 查找全局安装的 TypeScript 包路径
+     */
+    private findGlobalTypeScript;
+    /**
+     * 关闭连接
+     */
+    dispose(): Promise<void>;
+    /**
+     * 同步释放资源（用于进程退出时）
+     */
+    disposeSync(): void;
+}
+/**
+ * 创建 LSP Client 并初始化
+ */
+export declare function createLSPClient(process: ChildProcess, serverInfo: LSPServerInfo, rootUri: string): Promise<LSPClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/coder-harness/src/lsp/client.js

@@ -0,0 +1,490 @@
+/**
+ * @fileoverview LSP Client 实现
+ *
+ * 使用 vscode-jsonrpc 与 LSP 服务器通信
+ */
+import { createMessageConnection } from "vscode-jsonrpc";
+import { StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node";
+import { pathToFileURL } from "url";
+import path from "path";
+import fs from "fs";
+import { getLanguageId } from "./language-map.js";
+/**
+ * LSP Client
+ *
+ * 封装与 LSP 服务器的 JSON-RPC 通信
+ */
+export class LSPClient {
+    connection;
+    serverInfo;
+    rootUri;
+    pendingDiagnostics;
+    openDocuments; // 跟踪已打开的文档 URI
+    lastUsed;
+    disposed = false;
+    process; // 保存进程引用用于清理
+    /** 诊断请求序列号（递增） */
+    _requestIdCounter = 0;
+    constructor(process, serverInfo, rootUri) {
+        this.serverInfo = serverInfo;
+        this.rootUri = rootUri;
+        this.process = process; // 保存进程引用
+        this.pendingDiagnostics = new Map();
+        this.openDocuments = new Set();
+        this.lastUsed = Date.now();
+        this.disposed = false;
+        // 创建 JSON-RPC 连接
+        const reader = new StreamMessageReader(process.stdout);
+        const writer = new StreamMessageWriter(process.stdin);
+        this.connection = createMessageConnection(reader, writer);
+        // 设置通知处理器
+        this.setupNotificationHandlers();
+        // 开始监听
+        this.connection.listen();
+    }
+    /**
+     * 分配新的请求序列号
+     */
+    allocateRequestId() {
+        return ++this._requestIdCounter;
+    }
+    /**
+     * 设置通知处理器
+     */
+    setupNotificationHandlers() {
+        // 处理 publishDiagnostics 通知
+        this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+            const uri = params.uri;
+            // 获取当前活跃请求的版本号
+            // 只有当前活跃请求（发起 didChange 的请求）才能接收这个诊断
+            const currentVersion = this.activeRequestId;
+            // 存储诊断结果，带上版本号标记
+            // 这个诊断是针对 currentVersion 对应的请求的
+            this.diagnosticsWithVersion.set(uri, {
+                version: currentVersion,
+                diagnostics: params.diagnostics,
+            });
+            // 保留向后兼容：同时存储到 pendingDiagnostics
+            this.pendingDiagnostics.set(uri, params.diagnostics);
+        });
+        // 处理 window/logMessage 通知（用于调试）
+        this.connection.onNotification("window/logMessage", (params) => {
+            // Log at appropriate level based on type
+            // 1=Error, 2=Warning, 3=Info, 4=Log
+            if (params.type === 1) {
+                console.error(`[LSP Server Error] ${params.message}`);
+            }
+            else if (params.type === 2) {
+                console.warn(`[LSP Server Warning] ${params.message}`);
+            }
+            else {
+                console.log(`[LSP Server] ${params.message}`);
+            }
+        });
+        // 处理 window/workDoneProgress/create 请求
+        this.connection.onRequest("window/workDoneProgress/create", () => {
+            return null;
+        });
+        // 处理 workspace/configuration 请求
+        this.connection.onRequest("workspace/configuration", async () => {
+            return [this.serverInfo.initializationOptions ?? {}];
+        });
+        // 处理 workspace/workspaceFolders 请求
+        this.connection.onRequest("workspace/workspaceFolders", async () => {
+            return [
+                {
+                    name: "workspace",
+                    uri: this.rootUri,
+                },
+            ];
+        });
+        // 处理 client/registerCapability 请求
+        this.connection.onRequest("client/registerCapability", async () => { });
+        // 处理 client/unregisterCapability 请求
+        this.connection.onRequest("client/unregisterCapability", async () => { });
+    }
+    /**
+     * 初始化 LSP 会话
+     */
+    async initialize() {
+        try {
+            // 为 TypeScript 服务器准备初始化选项
+            let initOptions = this.serverInfo.initializationOptions ?? {};
+            // 如果是 TypeScript 服务器，设置全局 TypeScript 路径
+            if (this.serverInfo.id === "typescript") {
+                const tsPath = this.findGlobalTypeScript();
+                if (tsPath) {
+                    initOptions = {
+                        ...initOptions,
+                        // typescript-language-server 配置
+                        tsserver: {
+                            path: tsPath,
+                        },
+                        // 兼容旧版本
+                        typescript: {
+                            tsdk: tsPath,
+                        },
+                    };
+                }
+            }
+            await this.connection.sendRequest("initialize", {
+                processId: process.pid,
+                rootUri: this.rootUri,
+                rootPath: this.rootUri,
+                workspaceFolders: [
+                    {
+                        name: "workspace",
+                        uri: this.rootUri,
+                    },
+                ],
+                initializationOptions: initOptions,
+                capabilities: {
+                    window: {
+                        workDoneProgress: true,
+                    },
+                    workspace: {
+                        configuration: true,
+                        workspaceFolders: true,
+                        didChangeWatchedFiles: {
+                            dynamicRegistration: true,
+                        },
+                    },
+                    textDocument: {
+                        synchronization: {
+                            didOpen: true,
+                            didChange: true,
+                        },
+                        publishDiagnostics: {
+                            versionSupport: true,
+                        },
+                    },
+                },
+            });
+            await this.connection.sendNotification("initialized", {});
+            // 等待服务器完全初始化
+            // TypeScript 语言服务器需要时间来加载 tsserver 和设置内部状态
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            // 发送初始配置
+            if (this.serverInfo.initializationOptions) {
+                await this.connection.sendNotification("workspace/didChangeConfiguration", {
+                    settings: this.serverInfo.initializationOptions,
+                });
+            }
+        }
+        catch (error) {
+            throw new Error(`LSP initialize failed: ${error}`);
+        }
+    }
+    /**
+     * 文档版本号追踪
+     * 按 URI 索引，每次文档内容变化时递增
+     */
+    documentVersions = new Map();
+    /**
+     * 诊断结果存储（带版本标记）
+     * 用于解决并发请求时的诊断同步问题
+     */
+    diagnosticsWithVersion = new Map();
+    /**
+     * 活跃的请求追踪
+     * 用于确保每个请求只返回自己的诊断结果
+     */
+    activeRequestId = 0;
+    /**
+     * 打开文档
+     */
+    async openDocument(filePath, text) {
+        this.lastUsed = Date.now();
+        const uri = pathToFileURL(filePath).href;
+        // 检查文档是否已经打开，避免重复打开
+        if (this.openDocuments.has(uri)) {
+            // 文档已打开，检查是否需要更新内容
+            // 对于诊断场景，我们主要关心内容是否是最新的
+            // 如果提供了新文本，发送 didChange 通知
+            if (text) {
+                const version = (this.documentVersions.get(uri) ?? 1) + 1;
+                this.documentVersions.set(uri, version);
+                await this.connection.sendNotification("textDocument/didChange", {
+                    textDocument: {
+                        uri,
+                        version,
+                    },
+                    contentChanges: [{ text }],
+                });
+            }
+            return;
+        }
+        // 如果没有提供文本，读取文件
+        if (!text) {
+            const fs = await import("fs/promises");
+            text = await fs.readFile(filePath, "utf-8");
+        }
+        const languageId = getLanguageId(filePath);
+        // 初始化版本号为 1
+        this.documentVersions.set(uri, 1);
+        // 清空该 URI 的旧诊断，因为新打开的文档可能内容不同
+        // TypeScript 语言服务器会发送新的 publishDiagnostics 通知
+        this.pendingDiagnostics.delete(uri);
+        await this.connection.sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri,
+                languageId,
+                version: 1,
+                text,
+            },
+        });
+        // 标记文档为已打开
+        this.openDocuments.add(uri);
+    }
+    /**
+     * 获取诊断信息
+     *
+     * 使用请求序列号机制确保诊断同步：
+     * 1. 分配请求序列号
+     * 2. 设置为当前活跃请求
+     * 3. 发送 didChange 触发 LSP 服务器重新分析
+     * 4. 只返回与当前序列号匹配的诊断
+     */
+    async getDiagnostics(filePath) {
+        this.lastUsed = Date.now();
+        // 读取文件的最新内容，确保 LSP 服务器分析的是最新代码
+        let fileContent;
+        try {
+            fileContent = await fs.promises.readFile(filePath, "utf-8");
+        }
+        catch (error) {
+            // 文件不存在或读取失败时返回空诊断
+            return [];
+        }
+        const diagnosticsUri = pathToFileURL(filePath).href;
+        // 【关键修复】分配请求序列号
+        const requestId = this.allocateRequestId();
+        // 【关键修复】设置当前活跃请求
+        // 后续的 publishDiagnostics 通知会被标记上这个序列号
+        this.activeRequestId = requestId;
+        // 【关键修复】清除该 URI 的旧诊断
+        // 只有当前请求的诊断才会被返回
+        this.diagnosticsWithVersion.delete(diagnosticsUri);
+        this.pendingDiagnostics.delete(diagnosticsUri);
+        // 确保文档已打开并传入最新内容
+        // 这会触发 textDocument/didChange 通知让 LSP 服务器重新分析
+        // 注意：openDocument 内部也会递增 documentVersions
+        await this.openDocument(filePath, fileContent);
+        // 【关键修复】等待服务器处理诊断
+        // 只返回与当前请求序列号匹配的诊断
+        const maxWait = 30000; // 最多等待 30 秒（大型文件需要更长时间）
+        const pollInterval = 500; // 每 500ms 检查一次
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWait) {
+            // 【关键修复】检查是否有匹配当前请求序列号的诊断
+            const versioned = this.diagnosticsWithVersion.get(diagnosticsUri);
+            // 如果有诊断且版本匹配当前请求，返回诊断
+            if (versioned && versioned.diagnostics && versioned.diagnostics.length > 0) {
+                // 双重检查：确保版本号仍然匹配（可能已经被新请求覆盖）
+                if (versioned.version === requestId) {
+                    return versioned.diagnostics.map((raw) => this.convertDiagnostic(raw));
+                }
+                // 版本不匹配，说明有新请求了，继续等待
+            }
+            // 也检查 pendingDiagnostics（向后兼容）
+            const rawDiagnostics = this.pendingDiagnostics.get(diagnosticsUri);
+            if (rawDiagnostics && rawDiagnostics.length > 0) {
+                // 确保版本号匹配
+                if (versioned && versioned.version === requestId) {
+                    return rawDiagnostics.map((raw) => this.convertDiagnostic(raw));
+                }
+                // 如果 versioned 不存在或版本不匹配，可能有竞态，使用 pendingDiagnostics
+                // 但这不如 versioned 可靠
+                if (!versioned) {
+                    return rawDiagnostics.map((raw) => this.convertDiagnostic(raw));
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+        // 超时后返回空数组
+        return [];
+    }
+    /**
+     * 转换诊断信息
+     */
+    convertDiagnostic(raw) {
+        return {
+            range: {
+                start: {
+                    line: raw.range.start.line,
+                    character: raw.range.start.character,
+                },
+                end: {
+                    line: raw.range.end.line,
+                    character: raw.range.end.character,
+                },
+            },
+            severity: (raw.severity ?? 1),
+            code: raw.code,
+            source: raw.source,
+            message: raw.message,
+        };
+    }
+    /**
+     * 获取服务器 ID
+     */
+    getServerId() {
+        return this.serverInfo.id;
+    }
+    /**
+     * 获取最后使用时间
+     */
+    getLastUsed() {
+        return this.lastUsed;
+    }
+    /**
+     * 健康检查 - ping 连接验证
+     *
+     * 通过发送 $/cancelRequest 或简单的方法调用来验证连接是否仍然活跃
+     * 如果服务器已崩溃，连接应该会失败
+     *
+     * @returns true 如果连接健康，false 如果连接已断开
+     */
+    async ping() {
+        if (this.disposed) {
+            return false;
+        }
+        try {
+            // 使用 $/cancelRequest 来探测连接
+            // 如果服务器已崩溃，这个请求应该会失败
+            // 设置一个较短的超时，避免长时间等待
+            const timeoutPromise = new Promise((resolve) => {
+                setTimeout(() => resolve(false), 2000);
+            });
+            const pingPromise = new Promise(async (resolve) => {
+                try {
+                    // 尝试发送一个简单的请求来验证连接
+                    // 使用 window/showMessageRequest 因为它是一个简单的方法调用
+                    await this.connection.sendRequest("window/showMessageRequest", {
+                        type: 1,
+                        message: "health check",
+                        actions: [],
+                    });
+                    resolve(true);
+                }
+                catch {
+                    // 如果请求失败（可能是服务器不支持），尝试使用 $/cancelRequest
+                    try {
+                        await this.connection.sendRequest("$/cancelRequest", {
+                            id: null,
+                        });
+                        resolve(true);
+                    }
+                    catch {
+                        resolve(false);
+                    }
+                }
+            });
+            return await Promise.race([pingPromise, timeoutPromise]);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 查找全局安装的 TypeScript 包路径
+     */
+    findGlobalTypeScript() {
+        // 尝试从 bun 全局包目录查找
+        const bunGlobalPath = path.resolve(process.env.BUN_INSTALL ?? "/home/dzk/.bun", "lib/node_modules/typescript");
+        if (fs.existsSync(bunGlobalPath)) {
+            return bunGlobalPath;
+        }
+        // 尝试从 npm 全局包目录查找
+        const npmGlobalPath = path.resolve(process.env.NPM_CONFIG_PREFIX ?? "/usr/local", "lib/node_modules/typescript");
+        if (fs.existsSync(npmGlobalPath)) {
+            return npmGlobalPath;
+        }
+        // 尝试项目根目录的 node_modules/typescript
+        const projectRoot = path.resolve(__dirname, "../../../../"); // 从 dist/lsp 到项目根
+        const projectTSPath = path.join(projectRoot, "node_modules/typescript");
+        if (fs.existsSync(projectTSPath)) {
+            return projectTSPath;
+        }
+        // 尝试常见的全局包位置
+        const commonPaths = [
+            "/home/dzk/.bun/lib/node_modules/typescript",
+            "/usr/local/lib/node_modules/typescript",
+            "/root/.npm-global/lib/node_modules/typescript",
+        ];
+        for (const p of commonPaths) {
+            if (fs.existsSync(p)) {
+                return p;
+            }
+        }
+        return null;
+    }
+    /**
+     * 关闭连接
+     */
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        try {
+            // 添加超时机制，避免在测试环境中永久阻塞
+            const timeoutPromise = new Promise((resolve) => {
+                setTimeout(() => resolve(), 100);
+            });
+            const shutdownPromise = this.connection.sendRequest("shutdown");
+            await Promise.race([shutdownPromise, timeoutPromise]);
+            this.connection.sendNotification("exit");
+        }
+        catch {
+            // ignore
+        }
+        this.connection.dispose();
+        // 确保进程被终止（如果还没有退出）
+        if (this.process && !this.process.killed) {
+            try {
+                this.process.kill("SIGTERM");
+                // 给进程一点时间来退出
+                setTimeout(() => {
+                    if (!this.process.killed) {
+                        this.process.kill("SIGKILL");
+                    }
+                }, 100);
+            }
+            catch {
+                // 进程可能已经退出，忽略错误
+            }
+        }
+    }
+    /**
+     * 同步释放资源（用于进程退出时）
+     */
+    disposeSync() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        try {
+            this.connection.dispose();
+        }
+        catch {
+            // ignore
+        }
+        // 强制终止进程
+        if (this.process && !this.process.killed) {
+            try {
+                this.process.kill("SIGKILL");
+            }
+            catch {
+                // 进程可能已经退出，忽略错误
+            }
+        }
+    }
+}
+/**
+ * 创建 LSP Client 并初始化
+ */
+export async function createLSPClient(process, serverInfo, rootUri) {
+    const client = new LSPClient(process, serverInfo, rootUri);
+    await client.initialize();
+    return client;
+}
+//# sourceMappingURL=client.js.map

package/dist/coder-harness/src/lsp/client.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview LSPClient 测试
+ */
+export {};
+//# sourceMappingURL=client.test.d.ts.map