@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

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

@@ -1,36 +0,0 @@
-/**
- * @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

@@ -1,104 +0,0 @@
-/**
- * @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

@@ -1,490 +0,0 @@
-/**
- * @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

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