@ai-setting/roy-agent-cli 1.0.0

package/src/commands/lsp/check.ts

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview LSP Check Command
+ */
+
+import { CommandModule } from "yargs";
+import { createInstaller, LSP_PACKAGES, LSPConfigLoader } from "@ai-setting/roy-agent-coder-harness";
+
+/**
+ * 创建 lsp check 命令
+ */
+export const LspCheckCommand: CommandModule = {
+  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");
+    }
+  },
+};

package/src/commands/lsp/index.ts

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview LSP Command Group
+ */
+
+import { CommandModule } from "yargs";
+import { LspInstallCommand } from "./install";
+import { LspListCommand } from "./list";
+import { LspCheckCommand } from "./check";
+
+/**
+ * LSP Command
+ */
+export const LspCommand: CommandModule = {
+  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";
+export { LspListCommand } from "./list";
+export { LspCheckCommand } from "./check";

package/src/commands/lsp/install.ts

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview LSP Install Command
+ */
+
+import { CommandModule } from "yargs";
+import { createInstaller, LSP_PACKAGES } from "@ai-setting/roy-agent-coder-harness";
+
+/**
+ * 创建 lsp install 命令
+ */
+export const LspInstallCommand: CommandModule = {
+  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 as string,
+    });
+
+    const languages = argv.languages as string[] | undefined;
+
+    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: string[] = [];
+      const failed: string[] = [];
+
+      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");
+    }
+  },
+};

package/src/commands/lsp/list.ts

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview LSP List Command
+ */
+
+import { CommandModule } from "yargs";
+import { createInstaller, LSP_PACKAGES } from "@ai-setting/roy-agent-coder-harness";
+
+/**
+ * 创建 lsp list 命令
+ */
+export const LspListCommand: CommandModule = {
+  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`);
+  },
+};

package/src/commands/mcp/index.ts

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview MCP Commands
+ * 
+ * 命令组：roy mcp
+ */
+
+import { CommandModule } from "yargs";
+import { ListCommand } from "./list";
+import { ToolsCommand } from "./tools";
+import { ReloadCommand } from "./reload";
+
+export const McpCommand: CommandModule<object, {}> = {
+  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";
+export { ToolsCommand } from "./tools";
+export { ReloadCommand } from "./reload";

package/src/commands/mcp/list.ts

@@ -0,0 +1,116 @@
+/**
+ * @fileoverview MCP List Command
+ * 
+ * 命令：roy mcp list
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { McpComponent } from "@ai-setting/roy-agent-core";
+
+interface ListOptions {
+  json?: boolean;
+  quiet?: boolean;
+  config?: string;
+}
+
+export const ListCommand: CommandModule<object, ListOptions> = {
+  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") as McpComponent | undefined;
+
+      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: string) => {
+          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();
+    }
+  },
+};

package/src/commands/mcp/reload.ts

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview MCP Reload Command
+ * 
+ * 命令：roy mcp reload
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { McpComponent } from "@ai-setting/roy-agent-core";
+
+interface ReloadOptions {
+  config?: string;
+}
+
+export const ReloadCommand: CommandModule<object, ReloadOptions> = {
+  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") as McpComponent | undefined;
+
+      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();
+    }
+  },
+};

package/src/commands/mcp/tools.ts

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview MCP Tools Command
+ * 
+ * 命令：roy mcp tools
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { McpComponent } from "@ai-setting/roy-agent-core";
+
+interface ToolsOptions {
+  server?: string;
+  json?: boolean;
+  quiet?: boolean;
+  config?: string;
+}
+
+export const ToolsCommand: CommandModule<object, ToolsOptions> = {
+  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") as McpComponent | undefined;
+
+      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<string, typeof tools>();
+        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();
+    }
+  },
+};