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

package/dist/coder-harness/src/lsp/preload.integration.test.js

@@ -1,125 +0,0 @@
-/**
- * @fileoverview LSP 预加载和生命周期集成测试
- */
-import { describe, it, expect, afterEach } from "vitest";
-import { LSPManager, createGlobalLSPManager, clearGlobalLSPManager } from "./manager.js";
-// Mock LSPManager 内部组件
-class MockLSPClient {
-    disposed = false;
-    lastUsed = Date.now();
-    async ping() { return true; }
-    async getDiagnostics() { return []; }
-    getLastUsed() { return this.lastUsed; }
-    async dispose() { this.disposed = true; }
-}
-describe("LSP Preload Integration", () => {
-    // 测试配置
-    const testConfig = {
-        idleTimeout: 5000,
-        maxConnections: 5,
-        autoDownload: false,
-        preloadLanguages: ["typescript"],
-    };
-    // 清理全局状态，避免测试间相互影响
-    afterEach(async () => {
-        clearGlobalLSPManager();
-    });
-    describe("Global LSP Manager Lifecycle", () => {
-        it("should create global manager with config", () => {
-            const manager = createGlobalLSPManager(testConfig);
-            expect(manager).toBeDefined();
-            expect(typeof manager.dispose).toBe("function");
-            expect(typeof manager.prewarm).toBe("function");
-            expect(typeof manager.registerShutdownHandler).toBe("function");
-        });
-        it("should return same instance for multiple calls", () => {
-            const manager1 = createGlobalLSPManager(testConfig);
-            const manager2 = createGlobalLSPManager();
-            expect(manager1).toBe(manager2);
-        });
-        it("should have shutdown handler registration", () => {
-            const manager = createGlobalLSPManager(testConfig);
-            expect(typeof manager.registerShutdownHandler).toBe("function");
-            // 注册应该不抛出错误
-            expect(() => manager.registerShutdownHandler()).not.toThrow();
-        });
-        it("should dispose all connections", async () => {
-            const manager = createGlobalLSPManager(testConfig);
-            // 调用 dispose 不应该抛出错误
-            try {
-                await manager.dispose();
-            }
-            catch (error) {
-                expect(error).toBeUndefined();
-            }
-            // 多次调用应该安全
-            try {
-                await manager.dispose();
-            }
-            catch (error) {
-                expect(error).toBeUndefined();
-            }
-        });
-    });
-    describe("Prewarm functionality", () => {
-        it("should have prewarm method", () => {
-            const manager = createGlobalLSPManager(testConfig);
-            expect(typeof manager.prewarm).toBe("function");
-        });
-        it("should return promise from prewarm", async () => {
-            const manager = createGlobalLSPManager(testConfig);
-            const result = manager.prewarm();
-            // prewarm 返回 Promise，但可能因为缺少二进制而失败
-            expect(result).toBeInstanceOf(Promise);
-            // 等待结果
-            await result;
-        });
-    });
-    describe("Connection stats", () => {
-        it("should provide connection statistics", () => {
-            const manager = createGlobalLSPManager(testConfig);
-            const stats = manager.getStats();
-            expect(stats).toBeDefined();
-            expect(typeof stats.activeConnections).toBe("number");
-            expect(typeof stats.prewarmedConnections).toBe("number");
-            expect(typeof stats.totalServers).toBe("number");
-            expect(Array.isArray(stats.connections)).toBe(true);
-        });
-    });
-});
-describe("LSP Preload Configuration", () => {
-    it("should support preloadLanguages in config", () => {
-        const config = {
-            idleTimeout: 60000,
-            maxConnections: 10,
-            autoDownload: false,
-            preloadLanguages: ["typescript", "python"],
-        };
-        const manager = new LSPManager(config);
-        expect(manager).toBeDefined();
-        manager.dispose();
-    });
-    it("should support cleanupInterval in config", () => {
-        const config = {
-            idleTimeout: 60000,
-            maxConnections: 5,
-            autoDownload: false,
-            cleanupInterval: 15000, // 15 秒
-        };
-        const manager = new LSPManager(config);
-        expect(manager).toBeDefined();
-        manager.dispose();
-    });
-    it("should support healthCheckInterval in config", () => {
-        const config = {
-            idleTimeout: 60000,
-            maxConnections: 5,
-            autoDownload: false,
-            healthCheckInterval: 30000, // 30 秒
-        };
-        const manager = new LSPManager(config);
-        expect(manager).toBeDefined();
-        manager.dispose();
-    });
-});
-//# sourceMappingURL=preload.integration.test.js.map

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

@@ -1,72 +0,0 @@
-/**
- * @fileoverview LSP Server 实现
- *
- * 定义 LSP 服务器配置和管理
- */
-import { LSPClient } from "./client";
-import type { LSPServerInfo, LSPManagerConfig } from "../types/linter";
-/**
- * LSP 服务器类
- *
- * 封装 LSP 服务器的启动和管理
- */
-export declare class LSPServer {
-    private info;
-    private config;
-    constructor(info: LSPServerInfo, config: LSPManagerConfig);
-    /**
-     * 获取服务器 ID
-     */
-    get id(): string;
-    /**
-     * 获取支持的扩展名
-     */
-    get extensions(): string[];
-    /**
-     * 查找项目根目录
-     *
-     * 向上查找 rootPattern 中的文件
-     */
-    findRoot(filePath: string, workspaceRoot?: string): Promise<string | null>;
-    /**
-     * 检查二进制是否存在
-     */
-    checkBinary(): Promise<string | null>;
-    /**
-     * 下载 LSP 服务器二进制
-     *
-     * 使用 LSPDependencyInstaller 自动下载缺失的包
-     */
-    protected downloadBinary(): Promise<string | null>;
-    /**
-     * 查找全局安装的 TypeScript 包路径
-     */
-    private findGlobalTypeScript;
-    /**
-     * 创建 LSP Client
-     */
-    createClient(root: string): Promise<LSPClient | null>;
-}
-/**
- * LSP 服务器注册表
- */
-export declare class LSPServerRegistry {
-    private static servers;
-    /**
-     * 注册服务器
-     */
-    static register(info: LSPServerInfo): void;
-    /**
-     * 获取服务器
-     */
-    static get(id: string): LSPServerInfo | undefined;
-    /**
-     * 获取所有服务器 ID
-     */
-    static getServerIds(): string[];
-    /**
-     * 创建服务器实例
-     */
-    static create(id: string, config: LSPManagerConfig): LSPServer | null;
-}
-//# sourceMappingURL=server.d.ts.map

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

@@ -1,271 +0,0 @@
-/**
- * @fileoverview LSP Server 实现
- *
- * 定义 LSP 服务器配置和管理
- */
-import { spawn } from "child_process";
-import path from "path";
-import fs from "fs/promises";
-import { which } from "../util/which.js";
-import { createLSPClient } from "./client.js";
-import { LSPDependencyInstaller, LSP_PACKAGES } from "../lsp-deps/installer.js";
-/**
- * LSP 服务器类
- *
- * 封装 LSP 服务器的启动和管理
- */
-export class LSPServer {
-    info;
-    config;
-    constructor(info, config) {
-        this.info = info;
-        this.config = config;
-    }
-    /**
-     * 获取服务器 ID
-     */
-    get id() {
-        return this.info.id;
-    }
-    /**
-     * 获取支持的扩展名
-     */
-    get extensions() {
-        return this.info.extensions;
-    }
-    /**
-     * 查找项目根目录
-     *
-     * 向上查找 rootPattern 中的文件
-     */
-    async findRoot(filePath, workspaceRoot) {
-        const stopAt = workspaceRoot ?? path.parse(filePath).root;
-        let currentDir = path.dirname(filePath);
-        while (currentDir !== stopAt && currentDir !== "/") {
-            // 检查排除模式
-            if (this.info.excludePattern) {
-                for (const pattern of this.info.excludePattern) {
-                    const excludePath = path.join(currentDir, pattern);
-                    try {
-                        await fs.access(excludePath);
-                        // 找到了排除文件，返回 null
-                        return null;
-                    }
-                    catch {
-                        // 文件不存在，继续向上查找
-                    }
-                }
-            }
-            // 检查根目录标识文件
-            for (const pattern of this.info.rootPattern) {
-                const rootFile = path.join(currentDir, pattern);
-                try {
-                    await fs.access(rootFile);
-                    return currentDir;
-                }
-                catch {
-                    // 文件不存在，继续向上查找
-                }
-            }
-            currentDir = path.dirname(currentDir);
-        }
-        // 没有找到，返回 workspaceRoot 或文件所在目录
-        return workspaceRoot ?? path.dirname(filePath);
-    }
-    /**
-     * 检查二进制是否存在
-     */
-    async checkBinary() {
-        const cmd = this.info.command[0];
-        const binaryPath = which(cmd);
-        if (binaryPath)
-            return binaryPath;
-        // 如果配置了自动下载，尝试下载
-        if (this.config.autoDownload) {
-            return this.downloadBinary();
-        }
-        return null;
-    }
-    /**
-     * 下载 LSP 服务器二进制
-     *
-     * 使用 LSPDependencyInstaller 自动下载缺失的包
-     */
-    async downloadBinary() {
-        try {
-            const installer = new LSPDependencyInstaller({
-                target: "global",
-                installPath: this.config.installPath,
-            });
-            // 查找对应的包
-            const pkg = LSP_PACKAGES.find((p) => p.serverId === this.info.id);
-            if (!pkg) {
-                console.debug(`[LSPServer] No package registered for server: ${this.info.id}`);
-                return null;
-            }
-            // 安装包
-            const success = installer.install(this.info.id, { verbose: false });
-            if (!success) {
-                console.debug(`[LSPServer] Failed to install ${pkg.npmPackage}`);
-                return null;
-            }
-            // 返回安装后的二进制路径
-            const binaryPath = which(this.info.command[0]);
-            return binaryPath;
-        }
-        catch (error) {
-            console.debug(`[LSPServer] Error downloading binary:`, error);
-            return null;
-        }
-    }
-    /**
-     * 查找全局安装的 TypeScript 包路径
-     */
-    findGlobalTypeScript() {
-        const fs = require("fs");
-        // 尝试从 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;
-    }
-    /**
-     * 创建 LSP Client
-     */
-    async createClient(root) {
-        // 检查二进制
-        const binaryPath = await this.checkBinary();
-        if (!binaryPath) {
-            console.warn(`LSP server binary not found: ${this.info.command[0]}`);
-            return null;
-        }
-        // 启动进程
-        const args = this.info.args ?? ["--stdio"];
-        // 为 TypeScript 语言服务器配置全局 TypeScript 路径
-        const env = { ...process.env };
-        if (this.info.id === "typescript") {
-            // 查找全局 TypeScript 包路径
-            const globalTSPath = this.findGlobalTypeScript();
-            if (globalTSPath) {
-                // typescript-language-server 使用 TSSERVER_PATH 环境变量
-                env.TSSERVER_PATH = globalTSPath;
-            }
-        }
-        const proc = spawn(binaryPath, args, {
-            cwd: root,
-            stdio: ["pipe", "pipe", "pipe"],
-            env,
-        });
-        // 处理进程错误
-        proc.on("error", (err) => {
-            console.error(`LSP server process error: ${this.info.id} - ${err.message}`);
-        });
-        // 创建客户端
-        try {
-            const client = await createLSPClient(proc, this.info, `file://${root}`);
-            return client;
-        }
-        catch (error) {
-            console.error(`Failed to create LSP client: ${error}`);
-            proc.kill();
-            return null;
-        }
-    }
-}
-/**
- * LSP 服务器注册表
- */
-export class LSPServerRegistry {
-    static servers = new Map();
-    static {
-        // 注册内置服务器
-        this.register({
-            id: "typescript",
-            extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
-            rootPattern: ["package-lock.json", "bun.lockb", "bun.lock", "pnpm-lock.yaml", "yarn.lock"],
-            excludePattern: ["deno.json", "deno.jsonc"],
-            command: ["typescript-language-server", "--stdio"],
-        });
-        this.register({
-            id: "python",
-            extensions: [".py"],
-            rootPattern: ["pyproject.toml", "requirements.txt", "setup.py", ".python-version", "Pipfile"],
-            command: ["pyright-langserver", "--stdio"],
-        });
-        this.register({
-            id: "vue",
-            extensions: [".vue"],
-            rootPattern: ["package.json"],
-            command: ["vue-language-server", "--stdio"],
-        });
-        this.register({
-            id: "css",
-            extensions: [".css", ".scss", ".sass", ".less"],
-            rootPattern: ["package.json"],
-            command: ["vscode-css-language-server", "--stdio"],
-        });
-        this.register({
-            id: "html",
-            extensions: [".html", ".htm"],
-            rootPattern: ["package.json"],
-            command: ["vscode-html-language-server", "--stdio"],
-        });
-        this.register({
-            id: "json",
-            extensions: [".json", ".jsonc"],
-            rootPattern: ["package.json"],
-            command: ["vscode-json-language-server", "--stdio"],
-        });
-    }
-    /**
-     * 注册服务器
-     */
-    static register(info) {
-        this.servers.set(info.id, info);
-    }
-    /**
-     * 获取服务器
-     */
-    static get(id) {
-        return this.servers.get(id);
-    }
-    /**
-     * 获取所有服务器 ID
-     */
-    static getServerIds() {
-        return Array.from(this.servers.keys());
-    }
-    /**
-     * 创建服务器实例
-     */
-    static create(id, config) {
-        const info = this.get(id);
-        if (!info)
-            return null;
-        return new LSPServer(info, config);
-    }
-}
-//# sourceMappingURL=server.js.map

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

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

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

@@ -1,78 +0,0 @@
-/**
- * @fileoverview LSPServer 测试
- */
-import { describe, it, expect } from "vitest";
-import { LSPServerRegistry } from "./server.js";
-describe("LSPServer", () => {
-    describe("SERVERS", () => {
-        it("should have typescript server defined", () => {
-            const server = LSPServerRegistry.get("typescript");
-            expect(server).toBeDefined();
-            expect(server?.id).toBe("typescript");
-            expect(server?.extensions).toContain(".ts");
-        });
-        it("should have python server defined", () => {
-            const server = LSPServerRegistry.get("python");
-            expect(server).toBeDefined();
-            expect(server?.id).toBe("python");
-            expect(server?.extensions).toContain(".py");
-        });
-        it("should have vue server defined", () => {
-            const server = LSPServerRegistry.get("vue");
-            expect(server).toBeDefined();
-            expect(server?.id).toBe("vue");
-            expect(server?.extensions).toContain(".vue");
-        });
-        it("should have css server defined", () => {
-            const server = LSPServerRegistry.get("css");
-            expect(server).toBeDefined();
-            expect(server?.id).toBe("css");
-            expect(server?.extensions).toContain(".css");
-        });
-        it("should have html server defined", () => {
-            const server = LSPServerRegistry.get("html");
-            expect(server).toBeDefined();
-            expect(server?.id).toBe("html");
-            expect(server?.extensions).toContain(".html");
-        });
-        it("should have json server defined", () => {
-            const server = LSPServerRegistry.get("json");
-            expect(server).toBeDefined();
-            expect(server?.id).toBe("json");
-            expect(server?.extensions).toContain(".json");
-        });
-    });
-    describe("LSPServerRegistry", () => {
-        it("should return all server IDs", () => {
-            const ids = LSPServerRegistry.getServerIds();
-            expect(ids).toContain("typescript");
-            expect(ids).toContain("python");
-            expect(ids).toContain("vue");
-        });
-        it("should return undefined for unknown server", () => {
-            const server = LSPServerRegistry.get("unknown");
-            expect(server).toBeUndefined();
-        });
-    });
-    describe("findRoot", () => {
-        it("should be a function on LSPServer instance", () => {
-            const server = LSPServerRegistry.create("typescript", {
-                idleTimeout: 60000,
-                maxConnections: 5,
-                autoDownload: false,
-            });
-            expect(typeof server?.findRoot).toBe("function");
-        });
-    });
-    describe("createClient", () => {
-        it("should be a function on LSPServer instance", () => {
-            const server = LSPServerRegistry.create("typescript", {
-                idleTimeout: 60000,
-                maxConnections: 5,
-                autoDownload: false,
-            });
-            expect(typeof server?.createClient).toBe("function");
-        });
-    });
-});
-//# sourceMappingURL=server.test.js.map

package/dist/coder-harness/src/lsp-deps/config.d.ts

@@ -1,84 +0,0 @@
-/**
- * @fileoverview LSP 配置管理
- *
- * 管理 LSP 的安装路径、预加载等配置
- */
-/**
- * LSP 配置选项
- */
-export interface LSPConfigOptions {
-    /** 是否启用 LSP 功能 */
-    enabled?: boolean;
-    /** 是否预加载 LSP 服务器 */
-    preload?: boolean;
-    /** 预加载的语言服务器 ID 列表 */
-    preloadLanguages?: string[];
-    /** LSP 包安装路径 */
-    installPath?: string;
-    /** 空闲超时时间 (ms) */
-    idleTimeout?: number;
-    /** 最大并发连接数 */
-    maxConnections?: number;
-    /** 是否自动安装缺失的依赖 */
-    autoInstall?: boolean;
-    /** 跳过 LSP 依赖安装 */
-    skipDeps?: boolean;
-}
-/**
- * LSP 配置
- */
-export declare class LSPConfig {
-    enabled: boolean;
-    preload: boolean;
-    preloadLanguages: string[] | undefined;
-    installPath: string;
-    idleTimeout: number;
-    maxConnections: number;
-    autoInstall: boolean;
-    skipDeps: boolean;
-    constructor(options?: LSPConfigOptions);
-    /**
-     * 获取默认安装路径
-     */
-    private getDefaultInstallPath;
-    /**
-     * 获取全局 bin 路径
-     */
-    getGlobalBinPath(): string;
-    /**
-     * 转换为 JSON 对象
-     */
-    toJSON(): LSPConfigOptions;
-    /**
-     * 从 JSON 对象加载
-     */
-    static fromJSON(json: Partial<LSPConfigOptions>): LSPConfig;
-}
-/**
- * LSP 配置加载器
- */
-export declare class LSPConfigLoader {
-    private configPath;
-    constructor(configDir?: string);
-    /**
-     * 加载配置
-     */
-    load(): LSPConfig;
-    /**
-     * 保存配置
-     */
-    save(config: LSPConfig): void;
-    /**
-     * 获取配置路径
-     */
-    getConfigPath(): string;
-}
-/**
- * 获取默认 LSP 配置
- */
-export declare function getDefaultLSPConfig(): LSPConfig;
-/**
- * 创建 LSP 配置加载器
- */
-export declare function createLSPConfigLoader(configDir?: string): LSPConfigLoader;
-//# sourceMappingURL=config.d.ts.map