@ai-setting/roy-agent-cli 1.0.0

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@ai-setting/roy-agent-cli",
+  "version": "1.0.0",
+  "description": "CLI for roy-agent - Non-interactive command execution",
+  "type": "module",
+  "bin": {
+    "roy": "./dist/bin/roy"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli.js",
+      "types": "./dist/cli.d.ts"
+    },
+    "./bin": {
+      "import": "./dist/bin/roy.js"
+    }
+  },
+  "files": [
+    "dist/*.js",
+    "dist/*.d.ts",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/bin/**/*",
+    "src/**/*.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "bun run scripts/lsp-check.ts",
+    "build": "bun run scripts/build.ts",
+    "build:dev": "bun run scripts/build.ts --dev",
+    "build:prod": "bun run scripts/build.ts --production",
+    "build:ts": "tsc",
+    "build:single": "bun run scripts/build.ts --single",
+    "build:dev:single": "bun run scripts/build.ts --single --dev",
+    "build:prod:single": "bun run scripts/build.ts --single --production",
+    "typecheck": "tsc --noEmit --project tsconfig.typecheck.json",
+    "dev": "bun run src/bin/roy.ts",
+    "test": "bun test",
+    "cli": "bun run src/bin/roy.ts",
+    "prepublishOnly": "PRODUCTION=1 bun run scripts/build.ts --skip-install"
+  },
+  "dependencies": {
+    "@ai-setting/roy-agent-coder-harness": "workspace:*",
+    "@ai-setting/roy-agent-core": "workspace:*",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "pyright": "^1.1.409",
+    "typescript-language-server": "^5.1.3",
+    "vscode-css-languageserver-bin": "^1.4.0",
+    "vscode-html-languageserver-bin": "^1.4.0",
+    "vscode-json-languageserver": "^1.3.4",
+    "yargs": "^17.7.2",
+    "zod-to-json-schema": "^3.25.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/yargs": "^17.0.32",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ai-setting/roy-agent.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "keywords": [
+    "roy-agent",
+    "agent",
+    "ai",
+    "cli",
+    "command-line"
+  ],
+  "author": "ai-setting",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ai-setting/roy-agent/issues"
+  }
+}

package/src/bin/roy.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+/**
+ * @roy-agent/cli - CLI entry point
+ */
+
+import { runCli } from "../cli";
+
+runCli().catch((error) => {
+  console.error("Error:", error);
+  process.exit(1);
+});

package/src/cli.ts

@@ -0,0 +1,101 @@
+/**
+ * @fileoverview CLI Main Entry
+ */
+
+// @ts-ignore - yargs types issue with bundler module resolution
+import yargsLib from "yargs";
+import { hideBin } from "yargs/helpers";
+import { CliQuietModeService } from "./services/quiet-mode.service";
+import { ActCommand } from "./commands/act";
+import { InteractiveCommand } from "./commands/interactive";
+import { SessionsCommand } from "./commands/sessions/index";
+import { TasksCommand } from "./commands/tasks/index";
+import { SkillsCommand } from "./commands/skills/index";
+import { CommandsCommand } from "./commands/commands";
+import { ConfigCommand } from "./commands/config";
+import { McpCommand } from "./commands/mcp/index";
+import { ToolsCommand } from "./commands/tools/index";
+import { MemoryCommand } from "./commands/memory/index";
+import { EventSourceCommand } from "./commands/eventsource/index";
+import { DebugCommand } from "./commands/debug/index";
+import { WorkflowCommand } from "./commands/workflow/index";
+import { LspCommand } from "./commands/lsp/index";
+
+/**
+ * 全局 quiet 模式 middleware
+ * 
+ * 使用统一的 CliQuietModeService 管理 quiet 模式状态
+ * 与 LogTraceComponent 的 setQuietMode 机制保持一致
+ */
+function quietModeMiddleware(argv: Record<string, unknown>): void {
+  const quietService = CliQuietModeService.getInstance();
+  quietService.setQuietFromArgv(argv);
+}
+
+/**
+ * Plugin 帮助信息
+ */
+const PLUGIN_HELP = `
+Plugins:
+  coder-harness plugins:
+    lsp         LSP code intelligence (diagnostics, completions)
+    code-check  External command code checking (linter + type check)
+    reminder    Max iterations reminder for ReAct loop
+
+  component plugins:
+    task-tag    Task tag suggestion and similar task experience
+
+Examples:
+  --plugin lsp                   Enable LSP plugin
+  --plugin code-check            Enable external command checking
+  --plugin reminder              Enable iteration reminder
+  --plugin lsp code-check reminder  Enable multiple coder plugins
+  --plugin task-tag              Enable task-tag plugin
+  --plugin task-tag lsp          Enable both plugins`;
+
+export async function runCli(): Promise<void> {
+  const pkg = await import("../package.json", { with: { type: "json" } });
+
+  // @ts-ignore - yargs types issue
+  const yargs = yargsLib as any;
+
+  await yargs(hideBin(process.argv))
+    .scriptName("roy")
+    .version(pkg.default.version)
+    // 全局 quiet 选项
+    .option("quiet", {
+      alias: "q",
+      type: "boolean",
+      description: "Suppress all log output",
+      global: true,  // 所有子命令都继承此选项
+    })
+    // 全局 plugin 选项
+    .option("plugin", {
+      alias: "p",
+      type: "string",
+      array: true,
+      description: "Enable plugin (e.g., --plugin lsp, --plugin task-tag)",
+      global: true,
+    })
+    // 全局 middleware，在命令执行前设置 quiet 模式
+    .middleware(quietModeMiddleware, true)
+    .command(ActCommand)
+    .command(InteractiveCommand)
+    .command(SessionsCommand)
+    .command(TasksCommand)
+    .command(SkillsCommand)
+    .command(CommandsCommand)
+    .command(ConfigCommand)
+    .command(McpCommand)
+    .command(ToolsCommand)
+    .command(MemoryCommand)
+    .command(EventSourceCommand)
+    .command(DebugCommand)
+    .command(WorkflowCommand)
+    .command(LspCommand)
+    .demandCommand()
+    .help()
+    .alias("help", "h")
+    .epilog(PLUGIN_HELP)
+    .parse();
+}

package/src/commands/act.ts

@@ -0,0 +1,480 @@
+/**
+ * @fileoverview Act Command
+ * 
+ * 自然语言交互命令 - CLI 核心命令
+ * 
+ * 功能：
+ * - 支持在指定 session 上继续对话（--session）
+ * - 支持继续上次会话（--continue）
+ * - 支持上下文阈值自动压缩
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../services/environment.service";
+import { OutputService } from "../services/output.service";
+import { StreamOutputService } from "../services/stream-output.service";
+import { ContextHandlerService } from "../services/context-handler.service";
+import { ContextError, ErrorCodes, getTracerProvider } from "@ai-setting/roy-agent-core";
+import { CliQuietModeService } from "../services/quiet-mode.service";
+
+/**
+ * 生成唯一的 trace ID
+ */
+function generateTraceId(): string {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `req_${timestamp}_${random}`;
+}
+
+export interface ActOptions {
+  message?: string;
+  continue?: boolean;
+  session?: string;
+  model?: string;
+  env?: string;
+  config?: string;
+  quiet?: boolean;
+  reasoning?: boolean;
+  toolCalls?: boolean;
+  toolResults?: boolean;
+  plugins?: string[];  // 启用的 coder 插件列表，如 ["lsp", "code-check", "reminder"]
+}
+
+/**
+ * ActCommand - 自然语言交互命令
+ * 
+ * 通过自然语言驱动整个操作系统
+ * 
+ * @example
+ * # 在指定 session 上继续对话
+ * roy act "继续开发" --session s_abc123
+ * 
+ * # 继续上次会话
+ * roy act "继续" --continue
+ * 
+ * # 组合使用
+ * roy act "继续" --continue --reasoning
+ * 
+ * # 启用 coder 插件
+ * roy act "帮我重构这段代码" --plugin lsp --plugin code-check --plugin reminder
+ */
+export const ActCommand: CommandModule<object, ActOptions> = {
+  command: "act [message]",
+  describe: "自然语言交互 - 通过自然语言驱动整个操作系统",
+
+  builder: (yargs) =>
+    yargs
+      .positional("message", {
+        describe: "要执行的消息",
+        type: "string",
+      })
+      .option("continue", {
+        alias: "c",
+        describe: "继续上次会话",
+        type: "boolean",
+        default: false,
+      })
+      .option("session", {
+        alias: "s",
+        describe: "指定会话 ID",
+        type: "string",
+      })
+      .option("model", {
+        describe: "使用的模型",
+        type: "string",
+      })
+      .option("config", {
+        alias: "C",
+        describe: "配置文件路径",
+        type: "string",
+      })
+      .option("quiet", {
+        alias: "q",
+        describe: "安静模式：只输出最终结果（默认开启）",
+        type: "boolean",
+        default: true,
+      })
+      .option("reasoning", {
+        alias: "r",
+        describe: "显示 AI 思考过程",
+        type: "boolean",
+        default: false,
+      })
+      .option("tool-calls", {
+        describe: "显示工具调用",
+        type: "boolean",
+        default: false,
+      })
+      .option("tool-results", {
+        describe: "显示工具执行结果",
+        type: "boolean",
+        default: false,
+      })
+      .option("plugin", {
+        alias: "p",
+        describe: "启用 coder plugin (lsp, code-check, reminder)",
+        type: "array",
+        string: true,
+      }),
+
+  async handler(args) {
+    // 设置日志 quiet 模式
+    const quiet = args.quiet ?? true;
+    CliQuietModeService.getInstance().setQuiet(quiet);
+
+    const output = new OutputService();
+    output.configure({ quiet });
+
+    // 验证消息
+    if (!args.message) {
+      output.error("请提供要执行的消息，使用方式：roy act <消息>");
+      output.info("示例：roy act \"帮我写一个 hello world\"");
+      process.exit(1);
+    }
+
+    const envService = new EnvironmentService(output);
+
+    // Plugin adapter dispose 函数（需要在 finally 中调用）
+    let pluginAdapterDispose: (() => Promise<void>) | null = null;
+    // LSP Manager dispose 函数
+    let lspManagerDispose: (() => Promise<void>) | null = null;
+
+    // ========== 解析插件参数 ==========
+    const rawPlugins = args.plugin;
+    const pluginNames: string[] = Array.isArray(rawPlugins)
+      ? rawPlugins
+      : rawPlugins
+        ? [rawPlugins]
+        : [];
+
+    // coder-harness 插件名称集合
+    const CODER_HARNESS_PLUGINS = new Set(["lsp", "code-check", "reminder"]);
+
+    // 分离 coder-harness 插件和其他插件
+    const coderPluginNames: string[] = [];
+    const otherPluginNames: string[] = [];
+    
+    for (const plugin of pluginNames) {
+      const name = plugin.split(":")[0];
+      if (CODER_HARNESS_PLUGINS.has(name)) {
+        coderPluginNames.push(plugin);
+      } else {
+        otherPluginNames.push(plugin);
+      }
+    }
+
+    // 日志输出加载的插件
+    if (otherPluginNames.length > 0 && !quiet) {
+      output.info(`📌 加载插件: ${otherPluginNames.join(", ")}`);
+    }
+
+    try {
+      if (!quiet) {
+        output.info("初始化环境...");
+      }
+
+      // 创建环境
+      await envService.create({
+        envName: args.env,
+        configPath: args.config,
+        plugins: [...otherPluginNames, ...coderPluginNames],
+      });
+
+      const env = envService.getEnvironment();
+      const sessionComponent = envService.getSession();
+
+      if (!sessionComponent) {
+        output.error("SessionComponent not available");
+        process.exit(1);
+      }
+
+      // ========== Session 处理 ==========
+      let sessionId = args.session;
+      let isNewSession = false;
+
+      // 如果指定了 --continue，获取上次会话
+      if (args.continue && !sessionId) {
+        const activeSession = await sessionComponent.getActiveSession();
+        if (activeSession) {
+          sessionId = activeSession.id;
+          if (!quiet) {
+            output.info(`继续会话: ${activeSession.title} (${sessionId})`);
+          }
+        } else {
+          output.warn("没有找到上次会话，将创建新会话");
+        }
+      }
+
+      // 如果指定了 session，设置为 active 并获取会话信息
+      if (sessionId) {
+        await sessionComponent.setActiveSession(sessionId);
+        const session = await sessionComponent.get(sessionId);
+        if (session) {
+          if (!quiet) {
+            output.info(`会话: ${session.title} (${sessionId})`);
+          }
+        } else {
+          output.warn(`会话不存在: ${sessionId}，将创建新会话`);
+          sessionId = undefined;
+        }
+      }
+
+      // 如果没有 session，创建一个新会话
+      if (!sessionId) {
+        const newSession = await sessionComponent.create({
+          title: `Session - ${new Date().toLocaleString("zh-CN")}`,
+        });
+        sessionId = newSession.id;
+        isNewSession = true;
+        await sessionComponent.setActiveSession(sessionId);
+        if (!quiet) {
+          output.info(`创建新会话: ${newSession.title} (${sessionId})`);
+        }
+      }
+
+      // 初始化 SummaryAgent（用于 compact）
+      const llmComponent = envService.getLLM();
+      if (!env) {
+        output.error("Environment not available");
+        process.exit(1);
+      }
+      const promptComponent = env.getComponent("prompt") as any;
+      if (llmComponent && promptComponent) {
+        sessionComponent.setSummaryComponents(promptComponent, llmComponent);
+      }
+
+      // ========== Plugin 加载（coder-harness 插件） ==========
+      // 组件插件已通过 envService.create 加载
+      if (coderPluginNames.length > 0) {
+        try {
+          // 使用 globalHookManager（ToolComponent 内部使用）
+          const { globalHookManager } = await import("@ai-setting/roy-agent-core");
+          const { createPluginHookAdapter, createGlobalLSPManager } = await import("@ai-setting/roy-agent-coder-harness");
+          
+          const adapter = createPluginHookAdapter(globalHookManager as any, {
+            enableLSP: coderPluginNames.includes("lsp"),
+            enableCodeCheck: coderPluginNames.includes("code-check"),
+            enableReminder: coderPluginNames.includes("reminder"),
+          });
+
+          // 初始化插件（启动 LSP 预加载等）
+          await adapter.initialize();
+
+          pluginAdapterDispose = () => adapter.dispose();
+
+          // 过滤有效的插件名称
+          const enabledPlugins = coderPluginNames.filter(
+            (p) => CODER_HARNESS_PLUGINS.has(p.split(":")[0])
+          );
+          if (enabledPlugins.length > 0) {
+            console.log(`已启用插件: ${enabledPlugins.join(", ")}`)
+            output.success(`✅ 已启用插件: ${enabledPlugins.join(", ")}`);
+            
+            // 显示 LSP 预加载信息
+            if (coderPluginNames.includes("lsp") && !quiet) {
+              output.info(`🔧 LSP 服务预加载中，首次诊断可能需要等待...`);
+            }
+          }
+
+          // 如果启用了 LSP 插件，预热 LSP 服务器
+          if (coderPluginNames.includes("lsp")) {
+            try {
+              // 加载 LSP 配置
+              const { createLSPConfigLoader } = await import("@ai-setting/roy-agent-coder-harness");
+              const configLoader = createLSPConfigLoader();
+              const lspConfig = configLoader.load();
+
+              if (!quiet) {
+                output.info("正在预热 LSP 服务器...");
+                if (lspConfig.preload) {
+                  output.info("📋 使用配置文件中的预加载设置");
+                }
+              }
+              const lspManager = createGlobalLSPManager({
+                idleTimeout: lspConfig.idleTimeout ?? 300000, // 使用配置中的值
+                maxConnections: lspConfig.maxConnections ?? 10,
+                autoDownload: lspConfig.autoInstall ?? false,
+                preloadLanguages: lspConfig.preloadLanguages, // 使用配置中的预加载语言列表
+              });
+              // 注册 shutdown handler 确保进程退出时清理
+              lspManager.registerShutdownHandler();
+              // 保存 dispose 函数以便在退出时调用
+              lspManagerDispose = () => lspManager.dispose();
+              // 预热所有服务器（异步，不阻塞）
+              // 如果配置了 preload: true 或者明确启用了 lsp 插件，就预热
+              if (lspConfig.preload || coderPluginNames.includes("lsp")) {
+                lspManager.prewarm().then(() => {
+                  if (!quiet) {
+                    output.success("✅ LSP 服务器预热完成");
+                  }
+                }).catch((err) => {
+                  if (!quiet) {
+                    output.warn(`⚠ LSP 预热部分失败: ${err.message}`);
+                  }
+                });
+              }
+            } catch (error) {
+              output.warn(`⚠ LSP 预热失败: ${error}`);
+            }
+          }
+        } catch (error) {
+          output.error(`❌ 加载 coder-harness 插件失败: ${error}`);
+        }
+      }
+
+      // 创建流式输出服务
+      const streamService = new StreamOutputService({
+        showReasoning: args.reasoning,
+        showToolCalls: args.toolCalls,
+        showToolResults: args.toolResults,
+      });
+
+      // 设置 context window 配置（如果有 LLM component）
+      if (llmComponent) {
+        const contextConfig = llmComponent.getContextThresholdConfig("minimax");
+        streamService.setContextInfo(contextConfig.contextWindow, contextConfig.contextWindow * contextConfig.thresholdRatio);
+      }
+
+      // 订阅 LLM 事件和上下文事件进行流式输出
+      const unsubscribe = env.subscribeTo(
+        [
+          "llm.start",
+          "llm.text",
+          "llm.reasoning",
+          "llm.tool_call",
+          "llm.completed",
+          "llm.error",
+          "tool.result",
+          "tool.error",
+          "context.threshold_exceeded",
+          "context.compacting",
+          "context.compacted",
+        ],
+        (event) => {
+          // 工具执行事件（使用 log() 绕过 quiet 模式）
+          if (event.type === "llm.tool_call" && args.toolCalls) {
+            const payload = event.payload as any;
+            output.log(`🔧 ${payload.toolCall.name}`);
+            output.log(`   ${payload.toolCall.arguments}`);
+            return;
+          }
+          if (event.type === "tool.result" && args.toolResults) {
+            const payload = event.payload as any;
+            const result = payload.result?.output ?? payload.result?.error ?? "无输出";
+            output.log(`📤 ${payload.name}: ${String(result).substring(0, 200)}`);
+            return;
+          }
+          if (event.type === "tool.error") {
+            const payload = event.payload as { toolName?: string; error?: string };
+            output.error(`❌ ${payload.toolName ?? "unknown"}: ${payload.error ?? "unknown error"}`);
+            return;
+          }
+
+          // 上下文压缩事件
+          if (event.type === "context.threshold_exceeded" && !quiet) {
+            const payload = event.payload as any;
+            output.warn(`⚙ 上下文阈值 (${payload.totalTokens}/${payload.contextWindow})`);
+          }
+          if (event.type === "context.compacting" && !quiet) {
+            output.info("⚙ 压缩中...");
+          }
+          if (event.type === "context.compacted" && !quiet) {
+            const payload = event.payload as { checkpointId?: string };
+            output.success(`✓ 已压缩 (${payload.checkpointId ?? "unknown"})`);
+          }
+
+          // 其他事件交给 streamService 处理
+          streamService.handleEvent(event);
+        }
+      );
+
+      if (!quiet) {
+        output.info(`执行: ${args.message}`);
+      }
+
+      // ========================================================================
+      // 使用 OTel tracer 创建根 span
+      // 
+      // 使用统一的 roy-tracer，这样可以继承全局 context
+      // ========================================================================
+      const provider = getTracerProvider();
+      const tracer = provider.getTracer("roy-tracer");
+      const rootSpan = tracer.startSpan("act.execute", {
+        attributes: {
+          message: args.message.substring(0, 200),
+          sessionId,
+        },
+      });
+      const traceId = rootSpan.spanContext.traceId;
+      
+      if (!quiet) {
+        output.info(`[Trace] ${traceId}`);
+      }
+
+      // 设置全局 context
+      provider.setGlobalContext(rootSpan.spanContext);
+
+      // 创建 Context Handler（用于自动压缩）
+      const contextHandler = new ContextHandlerService(
+        env,
+        sessionComponent,
+        { maxRetries: 1, autoCompact: true }
+      );
+
+      // 构建 context（携带 trace id）
+      const context = {
+        sessionId,
+        metadata: {
+          originalQuery: args.message,
+          traceId,
+        },
+      };
+
+      // 执行查询（带上下文阈值处理）
+      let result: string;
+      try {
+        result = await contextHandler.handleQueryWithContext(args.message, context);
+        rootSpan.end(result);
+      } catch (error) {
+        rootSpan.setAttribute("error", String(error));
+        rootSpan.end(undefined, error instanceof Error ? error : new Error(String(error)));
+        
+        if (error instanceof ContextError && error.code === ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED) {
+          output.error(
+            `上下文阈值超出限制: ${error.usage?.totalTokens}/${error.contextWindow}`
+          );
+          output.info(
+            "请手动压缩会话: roy sessions compact " + (sessionId || "<session-id>")
+          );
+        }
+        throw error;
+      } finally {
+        // 清理全局 context
+        provider.setGlobalContext(undefined);
+      }
+
+      unsubscribe();
+
+      // 流式输出已完成
+      if (!quiet) {
+        output.success("执行完成");
+      }
+    } catch (error) {
+      output.error(`执行失败: ${error instanceof Error ? error.message : String(error)}`);
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    } finally {
+      // 清理 LSP Manager（关闭所有 LSP 连接和进程）
+      if (lspManagerDispose) {
+        await lspManagerDispose();
+      }
+      // 清理 PluginAdapter
+      if (pluginAdapterDispose) {
+        await pluginAdapterDispose();
+      }
+      await envService.dispose();
+    }
+  },
+};