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

package/dist/cli/src/commands/lsp/check.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview LSP Check Command
+ */
+import { CommandModule } from "yargs";
+/**
+ * 创建 lsp check 命令
+ */
+export declare const LspCheckCommand: CommandModule;
+//# sourceMappingURL=check.d.ts.map

package/dist/cli/src/commands/lsp/check.js

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview LSP Check Command
+ */
+import { createInstaller, LSP_PACKAGES, LSPConfigLoader } from "@ai-setting/roy-agent-coder-harness";
+/**
+ * 创建 lsp check 命令
+ */
+export const LspCheckCommand = {
+    command: "check [server-id]",
+    describe: "Check LSP server status and configuration",
+    builder: (yargs) => yargs
+        .positional("server-id", {
+        describe: "Check specific server (e.g., typescript)",
+        type: "string",
+    })
+        .option("verbose", {
+        alias: "v",
+        type: "boolean",
+        default: false,
+        description: "Show detailed information",
+    })
+        .option("json", {
+        type: "boolean",
+        default: false,
+        description: "Output as JSON",
+    }),
+    handler: async (argv) => {
+        const installer = createInstaller();
+        const configLoader = new LSPConfigLoader();
+        const config = configLoader.load();
+        if (argv.json) {
+            const servers = argv.serverId
+                ? LSP_PACKAGES.filter((p) => p.serverId === argv.serverId)
+                : LSP_PACKAGES;
+            const result = {
+                config: config.toJSON(),
+                servers: servers.map((pkg) => ({
+                    serverId: pkg.serverId,
+                    npmPackage: pkg.npmPackage,
+                    description: pkg.description,
+                    installed: installer.isInstalled(pkg.npmPackage),
+                    verify: installer.verify(pkg.serverId),
+                })),
+            };
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log("\n⚙️  LSP Configuration\n");
+        console.log(`  Config Path: ${configLoader.getConfigPath()}`);
+        console.log(`  Install Path: ${config.installPath}`);
+        console.log(`  Preload: ${config.preload ? "enabled" : "disabled"}`);
+        console.log(`  Idle Timeout: ${config.idleTimeout}ms`);
+        const servers = argv.serverId
+            ? LSP_PACKAGES.filter((p) => p.serverId === argv.serverId)
+            : LSP_PACKAGES;
+        console.log("\n📦 LSP Servers Status\n");
+        let hasIssues = false;
+        for (const pkg of servers) {
+            const verify = installer.verify(pkg.serverId);
+            const installed = verify.installed ? "✓ Installed" : "✗ Not installed";
+            console.log(`  ${pkg.serverId.padEnd(12)} ${pkg.description}`);
+            console.log(`    ${installed}`);
+            console.log(`    Package: ${pkg.npmPackage}`);
+            if (verify.binary) {
+                console.log(`    Binary in PATH: ${verify.binary}`);
+            }
+            else if (verify.installed) {
+                console.log(`    Warning: Installed but not in PATH`);
+                hasIssues = true;
+            }
+        }
+        console.log();
+        if (hasIssues) {
+            console.log("⚠️  Some servers are installed but not in PATH.");
+            console.log("    Run 'npm config get prefix' to check npm global path\n");
+        }
+    },
+};
+//# sourceMappingURL=check.js.map

package/dist/cli/src/commands/lsp/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview LSP Command Group
+ */
+import { CommandModule } from "yargs";
+/**
+ * LSP Command
+ */
+export declare const LspCommand: CommandModule;
+export { LspInstallCommand } from "./install";
+export { LspListCommand } from "./list";
+export { LspCheckCommand } from "./check";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/src/commands/lsp/index.js

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview LSP Command Group
+ */
+import { LspInstallCommand } from "./install.js";
+import { LspListCommand } from "./list.js";
+import { LspCheckCommand } from "./check.js";
+/**
+ * LSP Command
+ */
+export const LspCommand = {
+    command: "lsp",
+    describe: "Manage LSP (Language Server Protocol) servers",
+    builder: (yargs) => yargs
+        .command(LspInstallCommand)
+        .command(LspListCommand)
+        .command(LspCheckCommand)
+        .demandCommand()
+        .help(),
+    handler: () => {
+        console.log("Use 'roy lsp --help' for usage information");
+    },
+};
+export { LspInstallCommand } from "./install.js";
+export { LspListCommand } from "./list.js";
+export { LspCheckCommand } from "./check.js";
+//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/lsp/install.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview LSP Install Command
+ */
+import { CommandModule } from "yargs";
+/**
+ * 创建 lsp install 命令
+ */
+export declare const LspInstallCommand: CommandModule;
+//# sourceMappingURL=install.d.ts.map

package/dist/cli/src/commands/lsp/install.js

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview LSP Install Command
+ */
+import { createInstaller, LSP_PACKAGES } from "@ai-setting/roy-agent-coder-harness";
+/**
+ * 创建 lsp install 命令
+ */
+export const LspInstallCommand = {
+    command: "install [languages...]",
+    describe: "Install LSP server dependencies",
+    builder: (yargs) => yargs
+        .positional("languages", {
+        describe: "Languages to install (e.g., typescript, python)",
+        type: "string",
+    })
+        .option("global", {
+        alias: "g",
+        type: "boolean",
+        default: true,
+        description: "Install globally",
+    })
+        .option("local", {
+        alias: "l",
+        type: "string",
+        description: "Install to local path",
+    })
+        .option("all", {
+        alias: "a",
+        type: "boolean",
+        default: false,
+        description: "Install all available LSP servers",
+    })
+        .option("check", {
+        type: "boolean",
+        default: false,
+        description: "Only check if installed, don't install",
+    })
+        .option("verbose", {
+        alias: "v",
+        type: "boolean",
+        default: false,
+        description: "Verbose output",
+    }),
+    handler: async (argv) => {
+        const installer = createInstaller({
+            target: argv.local ? "local" : "global",
+            installPath: argv.local,
+        });
+        const languages = argv.languages;
+        if (argv.check) {
+            // Check mode
+            const installed = installer.getInstalledPackages();
+            const missing = installer.getMissingDependencies();
+            console.log("\n📦 LSP Server Status\n");
+            for (const pkg of LSP_PACKAGES) {
+                const isInstalled = installed.includes(pkg.serverId);
+                const status = isInstalled ? "✓ installed" : "✗ not installed";
+                console.log(`  ${status.padEnd(20)} ${pkg.serverId.padEnd(12)} ${pkg.description}`);
+            }
+            console.log(`\n${installed.length}/${LSP_PACKAGES.length} installed\n`);
+            if (missing.length > 0) {
+                console.log("Run 'roy lsp install' to install missing servers\n");
+            }
+            return;
+        }
+        if (languages && languages.length > 0) {
+            // Install specific languages
+            const success = [];
+            const failed = [];
+            for (const lang of languages) {
+                const langLower = lang.toLowerCase();
+                if (installer.install(langLower, { verbose: !!argv.verbose })) {
+                    success.push(langLower);
+                }
+                else {
+                    failed.push(langLower);
+                }
+            }
+            console.log(`\n📦 Installation Summary\n`);
+            if (success.length > 0) {
+                console.log(`  ✓ Installed: ${success.join(", ")}`);
+            }
+            if (failed.length > 0) {
+                console.log(`  ✗ Failed: ${failed.join(", ")}`);
+            }
+            console.log();
+        }
+        else if (argv.all) {
+            // Install all
+            console.log("\n📦 Installing all LSP servers...\n");
+            const result = installer.installAll({ verbose: !!argv.verbose });
+            console.log(`\n📦 Installation Summary\n`);
+            if (result.success.length > 0) {
+                console.log(`  ✓ Installed: ${result.success.join(", ")}`);
+            }
+            if (result.failed.length > 0) {
+                console.log(`  ✗ Failed: ${result.failed.join(", ")}`);
+            }
+            console.log();
+        }
+        else {
+            // Show available
+            console.log("\n📦 Available LSP Servers\n");
+            for (const pkg of LSP_PACKAGES) {
+                const isInstalled = installer.isInstalled(pkg.npmPackage);
+                const status = isInstalled ? "✓" : "○";
+                console.log(`  ${status} ${pkg.serverId.padEnd(12)} ${pkg.description}`);
+            }
+            console.log("\n  Run 'roy lsp install <language>' to install specific servers");
+            console.log("  Run 'roy lsp install --all' to install all servers\n");
+        }
+    },
+};
+//# sourceMappingURL=install.js.map

package/dist/cli/src/commands/lsp/list.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview LSP List Command
+ */
+import { CommandModule } from "yargs";
+/**
+ * 创建 lsp list 命令
+ */
+export declare const LspListCommand: CommandModule;
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/src/commands/lsp/list.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview LSP List Command
+ */
+import { createInstaller, LSP_PACKAGES } from "@ai-setting/roy-agent-coder-harness";
+/**
+ * 创建 lsp list 命令
+ */
+export const LspListCommand = {
+    command: "list",
+    describe: "List installed LSP servers",
+    builder: (yargs) => yargs
+        .option("verbose", {
+        alias: "v",
+        type: "boolean",
+        default: false,
+        description: "Show detailed information",
+    })
+        .option("json", {
+        type: "boolean",
+        default: false,
+        description: "Output as JSON",
+    }),
+    handler: async (argv) => {
+        const installer = createInstaller();
+        const installed = installer.getInstalledPackages();
+        if (argv.json) {
+            const result = LSP_PACKAGES.map((pkg) => ({
+                serverId: pkg.serverId,
+                npmPackage: pkg.npmPackage,
+                description: pkg.description,
+                installed: installed.includes(pkg.serverId),
+            }));
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log("\n📦 LSP Servers\n");
+        for (const pkg of LSP_PACKAGES) {
+            const isInstalled = installed.includes(pkg.serverId);
+            const status = isInstalled ? "✓" : "○";
+            const installedText = isInstalled ? "installed" : "not installed";
+            console.log(`  ${status} ${pkg.serverId.padEnd(12)} ${pkg.description}`);
+            console.log(`    ${pkg.npmPackage} - ${installedText}`);
+            if (argv.verbose && isInstalled) {
+                const verify = installer.verify(pkg.serverId);
+                if (verify.binary) {
+                    console.log(`    Binary: ${verify.binary}`);
+                }
+            }
+        }
+        console.log(`\n${installed.length}/${LSP_PACKAGES.length} installed\n`);
+    },
+};
+//# sourceMappingURL=list.js.map

package/dist/cli/src/commands/mcp/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview MCP Commands
+ *
+ * 命令组：roy mcp
+ */
+import { CommandModule } from "yargs";
+export declare const McpCommand: CommandModule<object, {}>;
+export { ListCommand } from "./list";
+export { ToolsCommand } from "./tools";
+export { ReloadCommand } from "./reload";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/src/commands/mcp/index.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview MCP Commands
+ *
+ * 命令组：roy mcp
+ */
+import { ListCommand } from "./list.js";
+import { ToolsCommand } from "./tools.js";
+import { ReloadCommand } from "./reload.js";
+export const McpCommand = {
+    command: "mcp",
+    describe: "MCP 服务器管理",
+    builder: (yargs) => yargs
+        .command(ListCommand)
+        .command(ToolsCommand)
+        .command(ReloadCommand)
+        .demandCommand(1, "请指定一个子命令")
+        .help(),
+    handler: () => { }, // Required but never called since subcommands handle themselves
+};
+export { ListCommand } from "./list.js";
+export { ToolsCommand } from "./tools.js";
+export { ReloadCommand } from "./reload.js";
+//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/mcp/list.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview MCP List Command
+ *
+ * 命令：roy mcp list
+ */
+import { CommandModule } from "yargs";
+interface ListOptions {
+    json?: boolean;
+    quiet?: boolean;
+    config?: string;
+}
+export declare const ListCommand: CommandModule<object, ListOptions>;
+export {};
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/src/commands/mcp/list.js

@@ -0,0 +1,100 @@
+/**
+ * @fileoverview MCP List Command
+ *
+ * 命令：roy mcp list
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const ListCommand = {
+    command: "list",
+    aliases: ["ls"],
+    describe: "列出所有 MCP 服务器及其状态",
+    builder: (yargs) => yargs
+        .option("json", {
+        alias: "j",
+        type: "boolean",
+        default: false,
+        description: "JSON 输出",
+    })
+        .option("quiet", {
+        alias: "q",
+        type: "boolean",
+        default: false,
+        description: "简洁输出",
+    }),
+    async handler(args) {
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: args.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const mcpComponent = env.getComponent("mcp");
+            if (!mcpComponent) {
+                output.error("McpComponent not available");
+                process.exit(1);
+            }
+            const servers = mcpComponent.listServers();
+            if (args.json) {
+                output.json({
+                    servers: servers.map(s => ({
+                        name: s.name,
+                        status: s.status,
+                        error: s.error,
+                        toolsCount: s.toolsCount,
+                    })),
+                    count: servers.length,
+                });
+            }
+            else if (args.quiet) {
+                servers.forEach(s => output.log(s.name));
+            }
+            else {
+                if (servers.length === 0) {
+                    output.log(chalk.yellow("No MCP servers configured"));
+                    return;
+                }
+                const statusColor = (status) => {
+                    switch (status) {
+                        case "connected": return chalk.green;
+                        case "connecting": return chalk.yellow;
+                        case "error": return chalk.red;
+                        case "disconnected": return chalk.gray;
+                        default: return chalk.white;
+                    }
+                };
+                const header = [
+                    chalk.bold("Name"),
+                    chalk.bold("Status"),
+                    chalk.bold("Tools"),
+                ].join(" | ");
+                const rows = servers.map(s => [
+                    chalk.cyan(s.name),
+                    statusColor(s.status)(`[${s.status}]`),
+                    s.toolsCount !== undefined ? String(s.toolsCount) : "-",
+                ].join(" | "));
+                output.log([
+                    `┌─ MCP Servers ${"─".repeat(40)}┐`,
+                    `│${header}│`,
+                    "├" + "─".repeat(header.length + 2) + "┤",
+                    ...rows.map(r => `│${r}│`),
+                    "└" + "─".repeat(header.length + 2) + "┘",
+                    "",
+                    chalk.gray(`Total: ${servers.length} servers`),
+                ].join("\n"));
+            }
+        }
+        catch (error) {
+            output.error(`Failed to list MCP servers: ${error}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=list.js.map

package/dist/cli/src/commands/mcp/reload.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview MCP Reload Command
+ *
+ * 命令：roy mcp reload
+ */
+import { CommandModule } from "yargs";
+interface ReloadOptions {
+    config?: string;
+}
+export declare const ReloadCommand: CommandModule<object, ReloadOptions>;
+export {};
+//# sourceMappingURL=reload.d.ts.map

package/dist/cli/src/commands/mcp/reload.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview MCP Reload Command
+ *
+ * 命令：roy mcp reload
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const ReloadCommand = {
+    command: "reload",
+    aliases: ["r"],
+    describe: "重新加载 MCP 服务器",
+    builder: (yargs) => yargs,
+    async handler(args) {
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: args.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const mcpComponent = env.getComponent("mcp");
+            if (!mcpComponent) {
+                output.error("McpComponent not available");
+                process.exit(1);
+            }
+            output.log(chalk.cyan("Reloading MCP servers..."));
+            await mcpComponent.reload();
+            const servers = mcpComponent.listServers();
+            const connected = servers.filter(s => s.status === "connected").length;
+            const errors = servers.filter(s => s.status === "error").length;
+            output.log(chalk.green(`✓ Reloaded ${servers.length} servers`));
+            if (connected > 0) {
+                output.log(chalk.green(`  • ${connected} connected`));
+            }
+            if (errors > 0) {
+                output.warn(`  • ${errors} failed`);
+                for (const server of servers.filter(s => s.status === "error")) {
+                    output.log(chalk.gray(`    - ${server.name}: ${server.error}`));
+                }
+            }
+        }
+        catch (error) {
+            output.error(`Failed to reload MCP servers: ${error}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=reload.js.map

package/dist/cli/src/commands/mcp/tools.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview MCP Tools Command
+ *
+ * 命令：roy mcp tools
+ */
+import { CommandModule } from "yargs";
+interface ToolsOptions {
+    server?: string;
+    json?: boolean;
+    quiet?: boolean;
+    config?: string;
+}
+export declare const ToolsCommand: CommandModule<object, ToolsOptions>;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/cli/src/commands/mcp/tools.js

@@ -0,0 +1,101 @@
+/**
+ * @fileoverview MCP Tools Command
+ *
+ * 命令：roy mcp tools
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const ToolsCommand = {
+    command: "tools",
+    aliases: ["t"],
+    describe: "列出所有 MCP 工具",
+    builder: (yargs) => yargs
+        .option("server", {
+        alias: "s",
+        type: "string",
+        description: "按服务器筛选",
+    })
+        .option("json", {
+        alias: "j",
+        type: "boolean",
+        default: false,
+        description: "JSON 输出",
+    })
+        .option("quiet", {
+        alias: "q",
+        type: "boolean",
+        default: false,
+        description: "简洁输出",
+    }),
+    async handler(args) {
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: args.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const mcpComponent = env.getComponent("mcp");
+            if (!mcpComponent) {
+                output.error("McpComponent not available");
+                process.exit(1);
+            }
+            let tools = mcpComponent.listTools();
+            // 按服务器筛选
+            if (args.server) {
+                tools = tools.filter(t => t.metadata?.tags?.includes(args.server));
+            }
+            if (args.json) {
+                output.json({
+                    tools: tools.map(t => ({
+                        name: t.name,
+                        description: t.description,
+                        category: t.metadata?.category,
+                        tags: t.metadata?.tags,
+                    })),
+                    count: tools.length,
+                });
+            }
+            else if (args.quiet) {
+                tools.forEach(t => output.log(t.name));
+            }
+            else {
+                if (tools.length === 0) {
+                    output.log(chalk.yellow("No MCP tools available"));
+                    return;
+                }
+                // 按服务器分组
+                const byServer = new Map();
+                for (const tool of tools) {
+                    const serverName = tool.metadata?.tags?.find(t => t !== "mcp") || "unknown";
+                    if (!byServer.has(serverName)) {
+                        byServer.set(serverName, []);
+                    }
+                    byServer.get(serverName).push(tool);
+                }
+                for (const [serverName, serverTools] of byServer) {
+                    output.log(chalk.bold.cyan(`\n[${serverName}] ${serverTools.length} tools`));
+                    for (const tool of serverTools) {
+                        const desc = tool.description.length > 80
+                            ? tool.description.slice(0, 77) + "..."
+                            : tool.description;
+                        output.log(`  ${chalk.green("+")} ${chalk.white(tool.name)}`);
+                        output.log(`    ${chalk.gray(desc)}`);
+                    }
+                }
+                output.log(chalk.gray(`\nTotal: ${tools.length} tools across ${byServer.size} servers`));
+            }
+        }
+        catch (error) {
+            output.error(`Failed to list MCP tools: ${error}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=tools.js.map

package/dist/cli/src/commands/memory/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Memory Commands Index - Simplified
+ *
+ * 导出所有 memory 子命令
+ *
+ * Simplified 设计：只保留 record 和 recall 两个核心命令
+ */
+export { MemoryCommand } from "./memory";
+export { RecordCommand } from "./record";
+export { RecallCommand } from "./recall";
+//# sourceMappingURL=index.d.ts.map