@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

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

@@ -0,0 +1,154 @@
+/**
+ * @fileoverview LSPClient 测试
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { LSPClient } from "./client.js";
+// Mock server info for testing
+const mockServerInfo = {
+    id: "typescript",
+    extensions: [".ts", ".tsx", ".js", ".jsx"],
+    rootPattern: ["package.json"],
+    command: ["typescript-language-server", "--stdio"],
+};
+describe("LSPClient", () => {
+    let mockProcess;
+    let mockStdout;
+    let mockStdin;
+    beforeEach(() => {
+        mockStdin = {
+            write: vi.fn(),
+            on: vi.fn(),
+            cork: vi.fn(),
+            uncork: vi.fn(),
+            destroy: vi.fn(),
+            end: vi.fn(),
+            setDefaultEncoding: vi.fn(),
+            writev: vi.fn(),
+            _destroy: vi.fn(),
+            closed: false,
+            destroyed: false,
+            writable: true,
+            writableEnded: false,
+            writableCorked: 0,
+            writableHighWaterMark: 16384,
+            writableLength: 0,
+        };
+        mockStdout = {
+            on: vi.fn(),
+            cork: vi.fn(),
+            uncork: vi.fn(),
+            destroy: vi.fn(),
+            end: vi.fn(),
+            setDefaultEncoding: vi.fn(),
+            writev: vi.fn(),
+            _destroy: vi.fn(),
+            closed: false,
+            destroyed: false,
+            readable: true,
+            readableFlowing: null,
+            readableHighWaterMark: 16384,
+            readableLength: 0,
+        };
+        mockProcess = {
+            pid: 12345,
+            stdout: mockStdout,
+            stdin: mockStdin,
+            on: vi.fn((event, cb) => {
+                if (event === "exit") {
+                    // Don't call immediately
+                }
+                return mockProcess;
+            }),
+            kill: vi.fn(),
+            connected: true,
+        };
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("constructor", () => {
+        it("should create client with valid process", () => {
+            const client = new LSPClient(mockProcess, mockServerInfo, "/tmp");
+            expect(client).toBeDefined();
+        });
+        it("should store server info", () => {
+            const client = new LSPClient(mockProcess, mockServerInfo, "/tmp");
+            expect(client.serverInfo).toEqual(mockServerInfo);
+        });
+    });
+    describe("getServerId", () => {
+        it("should return server ID", () => {
+            const client = new LSPClient(mockProcess, mockServerInfo, "/tmp");
+            expect(client.getServerId()).toBe("typescript");
+        });
+    });
+    describe("getLastUsed", () => {
+        it("should return last used timestamp", () => {
+            const client = new LSPClient(mockProcess, mockServerInfo, "/tmp");
+            const now = Date.now();
+            expect(client.getLastUsed()).toBeGreaterThanOrEqual(now - 1000);
+        });
+    });
+    describe("dispose", () => {
+        it("should set disposed flag", async () => {
+            const client = new LSPClient(mockProcess, mockServerInfo, "/tmp");
+            await client.dispose();
+            // After dispose, the client should be marked as disposed
+            // Note: kill is called internally but we can't test it with mocks
+            expect(client).toBeDefined();
+        });
+    });
+    describe("getDiagnostics synchronization", () => {
+        /**
+         * Test case: Concurrent getDiagnostics calls should return diagnostics
+         * for the correct file version, not stale diagnostics from previous requests.
+         *
+         * This is the core bug we're fixing - when multiple concurrent edits happen:
+         * 1. First getDiagnostics(requestId=1) is called
+         * 2. Second getDiagnostics(requestId=2) is called before first completes
+         * 3. First request should only return diagnostics that arrived AFTER its request
+         * 4. Second request should return diagnostics that arrived AFTER its request
+         */
+        it("should return stale diagnostics when not waiting for correct version", async () => {
+            // This test demonstrates the BUG: without proper synchronization,
+            // getDiagnostics may return diagnostics from a different request
+            // 
+            // Scenario:
+            // - Request 1 starts at time T1, expects diagnostic A
+            // - Request 2 starts at time T2, expects diagnostic B  
+            // - Diagnostic B arrives at time T2 (but A hasn't arrived yet)
+            // - Request 1 returns diagnostic B (WRONG - it's from a later version)
+            // This is a placeholder for the actual implementation test
+            // The real test would need to mock the LSP server responses
+            expect(true).toBe(true);
+        });
+        it("should isolate diagnostics between concurrent requests", async () => {
+            // Test that the requestId mechanism properly isolates diagnostics
+            // This is a conceptual test - the actual implementation would need
+            // integration with a mock LSP server
+            // Expected behavior after fix:
+            // - Each getDiagnostics call gets a unique requestId
+            // - Diagnostics are tagged with the requestId that was active when they arrived
+            // - Each request only returns diagnostics tagged with its own requestId
+            // Create client
+            const client = new LSPClient(mockProcess, mockServerInfo, "/tmp");
+            // Verify requestId counter exists and starts at 0
+            expect(client._requestIdCounter).toBe(0);
+            // Access the version tracking mechanism
+            expect(client.diagnosticsWithVersion).toBeDefined();
+            expect(client.activeRequestId).toBeDefined();
+            // Verify mechanism is in place
+            expect(client.diagnosticsWithVersion instanceof Map).toBe(true);
+            await client.dispose();
+        });
+        it("should track file versions separately per URI", async () => {
+            // Test that multiple files can be tracked independently
+            const client = new LSPClient(mockProcess, mockServerInfo, "/tmp");
+            // Verify document versions map exists
+            expect(client.documentVersions).toBeDefined();
+            expect(client.documentVersions instanceof Map).toBe(true);
+            await client.dispose();
+        });
+    });
+});
+//# sourceMappingURL=client.test.js.map

package/dist/coder-harness/src/lsp/language-map.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview 语言到 LSP 服务器的映射
+ *
+ * 定义文件扩展名到语言 ID 和 LSP 服务器的映射关系
+ */
+/**
+ * 文件扩展名到语言 ID 的映射
+ */
+export declare const LANGUAGE_EXTENSIONS: Record<string, string>;
+/**
+ * 文件扩展名到 LSP 服务器 ID 的映射
+ */
+export declare const SERVER_BY_EXTENSION: Record<string, string>;
+/**
+ * 根据文件路径获取对应的 LSP 服务器 ID
+ *
+ * @param filePath 文件路径
+ * @returns 服务器 ID，如果不支持则返回 null
+ */
+export declare function getServerId(filePath: string): string | null;
+/**
+ * 根据文件路径获取语言 ID
+ *
+ * @param filePath 文件路径
+ * @returns 语言 ID
+ */
+export declare function getLanguageId(filePath: string): string;
+/**
+ * 检查文件是否被支持
+ *
+ * @param filePath 文件路径
+ * @returns 是否支持
+ */
+export declare function isSupported(filePath: string): boolean;
+/**
+ * 根据语言 ID 获取所有支持的文件扩展名
+ *
+ * @param serverId LSP 服务器 ID
+ * @returns 文件扩展名数组
+ */
+export declare function getExtensionsByServer(serverId: string): string[];
+//# sourceMappingURL=language-map.d.ts.map

package/dist/coder-harness/src/lsp/language-map.js

@@ -0,0 +1,105 @@
+/**
+ * @fileoverview 语言到 LSP 服务器的映射
+ *
+ * 定义文件扩展名到语言 ID 和 LSP 服务器的映射关系
+ */
+import path from "path";
+/**
+ * 文件扩展名到语言 ID 的映射
+ */
+export const LANGUAGE_EXTENSIONS = {
+    // TypeScript/JavaScript
+    ".ts": "typescript",
+    ".tsx": "typescriptreact",
+    ".js": "javascript",
+    ".jsx": "javascriptreact",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    // Python
+    ".py": "python",
+    // Vue
+    ".vue": "vue",
+    // CSS
+    ".css": "css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".less": "less",
+    // HTML
+    ".html": "html",
+    ".htm": "html",
+    // JSON
+    ".json": "json",
+    ".jsonc": "jsonc",
+};
+/**
+ * 文件扩展名到 LSP 服务器 ID 的映射
+ */
+export const SERVER_BY_EXTENSION = {
+    // TypeScript/JavaScript
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "typescript",
+    ".jsx": "typescript",
+    ".mjs": "typescript",
+    ".cjs": "typescript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    // Python
+    ".py": "python",
+    // Vue
+    ".vue": "vue",
+    // CSS
+    ".css": "css",
+    ".scss": "css",
+    ".sass": "css",
+    ".less": "css",
+    // HTML
+    ".html": "html",
+    ".htm": "html",
+    // JSON
+    ".json": "json",
+    ".jsonc": "json",
+};
+/**
+ * 根据文件路径获取对应的 LSP 服务器 ID
+ *
+ * @param filePath 文件路径
+ * @returns 服务器 ID，如果不支持则返回 null
+ */
+export function getServerId(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return SERVER_BY_EXTENSION[ext] ?? null;
+}
+/**
+ * 根据文件路径获取语言 ID
+ *
+ * @param filePath 文件路径
+ * @returns 语言 ID
+ */
+export function getLanguageId(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return LANGUAGE_EXTENSIONS[ext] ?? "plaintext";
+}
+/**
+ * 检查文件是否被支持
+ *
+ * @param filePath 文件路径
+ * @returns 是否支持
+ */
+export function isSupported(filePath) {
+    return getServerId(filePath) !== null;
+}
+/**
+ * 根据语言 ID 获取所有支持的文件扩展名
+ *
+ * @param serverId LSP 服务器 ID
+ * @returns 文件扩展名数组
+ */
+export function getExtensionsByServer(serverId) {
+    return Object.entries(SERVER_BY_EXTENSION)
+        .filter(([, id]) => id === serverId)
+        .map(([ext]) => ext);
+}
+//# sourceMappingURL=language-map.js.map

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

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

package/dist/coder-harness/src/lsp/language-map.test.js

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview LanguageMap 测试
+ */
+import { describe, it, expect } from "vitest";
+import { getServerId, getLanguageId, isSupported, LANGUAGE_EXTENSIONS, SERVER_BY_EXTENSION } from "./language-map.js";
+describe("LanguageMap", () => {
+    describe("getServerId", () => {
+        it("should return typescript server for .ts files", () => {
+            expect(getServerId("/path/to/file.ts")).toBe("typescript");
+        });
+        it("should return typescript server for .tsx files", () => {
+            expect(getServerId("/path/to/file.tsx")).toBe("typescript");
+        });
+        it("should return typescript server for .js files", () => {
+            expect(getServerId("/path/to/file.js")).toBe("typescript");
+        });
+        it("should return python server for .py files", () => {
+            expect(getServerId("/path/to/file.py")).toBe("python");
+        });
+        it("should return vue server for .vue files", () => {
+            expect(getServerId("/path/to/file.vue")).toBe("vue");
+        });
+        it("should return css server for .css files", () => {
+            expect(getServerId("/path/to/file.css")).toBe("css");
+        });
+        it("should return html server for .html files", () => {
+            expect(getServerId("/path/to/file.html")).toBe("html");
+        });
+        it("should return json server for .json files", () => {
+            expect(getServerId("/path/to/file.json")).toBe("json");
+        });
+        it("should return null for unsupported extensions", () => {
+            expect(getServerId("/path/to/file.txt")).toBeNull();
+            expect(getServerId("/path/to/file.md")).toBeNull();
+            expect(getServerId("/path/to/file.unknown")).toBeNull();
+        });
+    });
+    describe("getLanguageId", () => {
+        it("should return typescript for .ts files", () => {
+            expect(getLanguageId("/path/to/file.ts")).toBe("typescript");
+        });
+        it("should return typescriptreact for .tsx files", () => {
+            expect(getLanguageId("/path/to/file.tsx")).toBe("typescriptreact");
+        });
+        it("should return javascript for .js files", () => {
+            expect(getLanguageId("/path/to/file.js")).toBe("javascript");
+        });
+        it("should return python for .py files", () => {
+            expect(getLanguageId("/path/to/file.py")).toBe("python");
+        });
+        it("should return vue for .vue files", () => {
+            expect(getLanguageId("/path/to/file.vue")).toBe("vue");
+        });
+        it("should return css for .css files", () => {
+            expect(getLanguageId("/path/to/file.css")).toBe("css");
+        });
+        it("should return html for .html files", () => {
+            expect(getLanguageId("/path/to/file.html")).toBe("html");
+        });
+        it("should return json for .json files", () => {
+            expect(getLanguageId("/path/to/file.json")).toBe("json");
+        });
+        it("should return plaintext for unsupported extensions", () => {
+            expect(getLanguageId("/path/to/file.txt")).toBe("plaintext");
+            expect(getLanguageId("/path/to/file.unknown")).toBe("plaintext");
+        });
+    });
+    describe("isSupported", () => {
+        it("should return true for supported extensions", () => {
+            expect(isSupported("/path/to/file.ts")).toBe(true);
+            expect(isSupported("/path/to/file.py")).toBe(true);
+            expect(isSupported("/path/to/file.vue")).toBe(true);
+        });
+        it("should return false for unsupported extensions", () => {
+            expect(isSupported("/path/to/file.txt")).toBe(false);
+            expect(isSupported("/path/to/file.md")).toBe(false);
+        });
+    });
+    describe("LANGUAGE_EXTENSIONS", () => {
+        it("should have entries for common languages", () => {
+            expect(LANGUAGE_EXTENSIONS[".ts"]).toBe("typescript");
+            expect(LANGUAGE_EXTENSIONS[".py"]).toBe("python");
+            expect(LANGUAGE_EXTENSIONS[".vue"]).toBe("vue");
+            expect(LANGUAGE_EXTENSIONS[".css"]).toBe("css");
+        });
+    });
+    describe("SERVER_BY_EXTENSION", () => {
+        it("should map extensions to server IDs", () => {
+            expect(SERVER_BY_EXTENSION[".ts"]).toBe("typescript");
+            expect(SERVER_BY_EXTENSION[".py"]).toBe("python");
+            expect(SERVER_BY_EXTENSION[".vue"]).toBe("vue");
+        });
+    });
+});
+//# sourceMappingURL=language-map.test.js.map

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

@@ -0,0 +1,166 @@
+/**
+ * @fileoverview LSP 连接管理器
+ *
+ * 管理 LSP 客户端连接池，按需创建/复用/清理连接
+ * 支持预加载模式和全局单例
+ */
+import type { LSPManagerConfig, Diagnostic } from "../types/linter";
+import { LSPClient } from "./client";
+/**
+ * 健康检查结果
+ */
+export interface HealthCheckResult {
+    /** 连接键 */
+    key: string;
+    /** 服务器 ID */
+    serverId: string;
+    /** 是否健康 */
+    healthy: boolean;
+    /** 错误信息（如果 unhealthy） */
+    error?: string;
+}
+/**
+ * 连接统计信息
+ */
+export interface ConnectionStats {
+    /** 活跃连接数 */
+    activeConnections: number;
+    /** 预加载连接数 */
+    prewarmedConnections: number;
+    /** 总服务器数 */
+    totalServers: number;
+    /** 连接详情 */
+    connections: Array<{
+        key: string;
+        serverId: string;
+        root: string;
+        lastUsed: number;
+        isPrewarmed: boolean;
+    }>;
+}
+/**
+ * LSP 连接管理器
+ *
+ * 负责 LSP 客户端的生命周期管理：
+ * - 按需创建连接
+ * - 连接池复用
+ * - 空闲连接清理
+ * - 预加载支持
+ * - 连接健康检查
+ */
+export declare class LSPManager {
+    private connections;
+    private servers;
+    private config;
+    private shutdownHandlersRegistered;
+    /** 预加载的连接缓存，按 serverId:root 索引 */
+    private _prewarmedConnections;
+    /** 清理定时器 */
+    private cleanupTimer;
+    /** 健康检查定时器 */
+    private healthCheckTimer;
+    /** 健康检查间隔（毫秒），默认 60000 */
+    private healthCheckInterval;
+    constructor(config: LSPManagerConfig);
+    /**
+     * 预加载 LSP 服务器
+     *
+     * 实际启动 LSP 服务器进程并建立连接
+     *
+     * @param serverIds 要预加载的服务器 ID 列表，默认使用配置中的 preloadLanguages
+     * @param workspaceRoot 预加载的工作区根目录
+     */
+    prewarm(serverIds?: string[], workspaceRoot?: string): Promise<void>;
+    /**
+     * 预加载单个服务器
+     *
+     * @param serverId 服务器 ID
+     * @param root 工作区根目录
+     */
+    private prewarmServer;
+    /**
+     * 获取或创建连接，优先使用预加载的连接
+     *
+     * @param serverId 服务器 ID
+     * @param filePath 文件路径
+     */
+    getOrCreateConnection(serverId: string, filePath: string): Promise<LSPClient | null>;
+    /**
+     * 注册进程退出时的清理处理器
+     *
+     * 确保进程退出时自动清理 LSP 服务器资源
+     */
+    registerShutdownHandler(): void;
+    /**
+     * 获取文件的诊断信息
+     *
+     * @param filePath 文件路径
+     * @returns 诊断信息数组
+     */
+    getDiagnostics(filePath: string): Promise<Diagnostic[]>;
+    /**
+     * 获取或创建客户端连接
+     *
+     * @deprecated 使用 getOrCreateConnection 代替
+     */
+    private getOrCreateClient;
+    /**
+     * 获取或创建服务器实例
+     */
+    private getOrCreateServer;
+    /**
+     * 清理过期连接
+     */
+    private cleanupIfNeeded;
+    /**
+     * 清理空闲超时的连接
+     *
+     * 定期调用以清理长时间未使用的连接
+     */
+    cleanupIdle(): Promise<void>;
+    /**
+     * 执行健康检查，检测并移除已崩溃的连接
+     *
+     * 定期调用以检测死连接（服务器崩溃等）
+     * 会移除不健康的连接并返回检查结果
+     *
+     * @returns 健康检查结果列表
+     */
+    healthCheck(): Promise<HealthCheckResult[]>;
+    /**
+     * 执行健康检查的内部实现
+     *
+     * @returns 健康检查结果列表
+     */
+    private performHealthCheck;
+    /**
+     * 获取连接统计信息
+     *
+     * @returns 连接统计信息
+     */
+    getStats(): ConnectionStats;
+    /**
+     * 释放所有资源
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * 获取全局 LSP Manager 实例
+ */
+export declare function getGlobalLSPManager(): LSPManager | null;
+/**
+ * 创建或获取全局 LSP Manager 实例
+ *
+ * @param config 初始化配置（仅首次调用生效）
+ * @returns 全局 LSP Manager 实例
+ */
+export declare function createGlobalLSPManager(config?: LSPManagerConfig): LSPManager;
+/**
+ * 全局 LSP Manager 实例（惰性创建）
+ */
+export declare const globalLSPManager: LSPManager;
+/**
+ * 清除全局 LSP Manager（主要用于测试）
+ */
+export declare function clearGlobalLSPManager(): void;
+//# sourceMappingURL=manager.d.ts.map