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

package/src/bin/roy.ts

@@ -1,12 +0,0 @@
-#!/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

@@ -1,101 +0,0 @@
-/**
- * @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

@@ -1,480 +0,0 @@
-/**
- * @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();
-    }
-  },
-};

package/src/commands/commands-add.ts

@@ -1,110 +0,0 @@
-/**
- * @fileoverview Commands Add Command
- * 
- * 添加收藏命令
- */
-
-import { CommandModule } from "yargs";
-import { EnvironmentService } from "../services/environment.service";
-import { OutputService } from "../services/output.service";
-import chalk from "chalk";
-import type { CommandsComponent } from "@ai-setting/roy-agent-core";
-
-export interface CommandsAddOptions {
-  name: string;
-  target: string;
-  global: boolean;
-  local: boolean;
-  description: string;
-  tips: string;
-  config?: string;
-}
-
-export const CommandsAddCommand: CommandModule<object, CommandsAddOptions> = {
-  command: "add <name> <target>",
-  describe: "添加收藏命令（自动创建 symlink）",
-
-  builder: (yargs) =>
-    yargs
-      .positional("name", {
-        describe: "命令名称",
-        type: "string",
-        demandOption: true,
-      })
-      .positional("target", {
-        describe: "目标命令路径或名称",
-        type: "string",
-        demandOption: true,
-      })
-      .option("global", {
-        alias: "g",
-        describe: "添加到用户级别目录（默认）",
-        type: "boolean",
-        default: true,
-      })
-      .option("local", {
-        alias: "l",
-        describe: "添加到项目级别目录",
-        type: "boolean",
-        default: false,
-      })
-      .option("description", {
-        alias: "d",
-        describe: "命令功能描述（用于 AI Prompt 注入）",
-        type: "string",
-        demandOption: true,
-      })
-      .option("tips", {
-        alias: "t",
-        describe: "探索提示（告诉用户如何使用 --help 探索）",
-        type: "string",
-        demandOption: true,
-      })
-      .option("config", {
-        describe: "配置文件路径",
-        type: "string",
-      }),
-
-  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 commandsComponent = env.getComponent("commands") as CommandsComponent | undefined;
-
-      if (!commandsComponent) {
-        output.error("CommandsComponent not available");
-        process.exit(1);
-      }
-
-      const source = args.local ? "project" : "user";
-
-      await commandsComponent.add({
-        name: args.name,
-        target: args.target,
-        source,
-        description: args.description,
-        tips: args.tips,
-      });
-
-      const dirs = await commandsComponent.getCommandDirs();
-      const targetDir = source === "user" ? dirs.user : dirs.project;
-
-      output.log(chalk.green(`✅ 已添加命令 '${args.name}'`));
-      output.log(chalk.gray(`   目标: ${args.target}`));
-      output.log(chalk.gray(`   位置: ${targetDir}/${args.name}`));
-      output.log(chalk.gray(`   级别: ${source === "user" ? "USER" : "PROJECT"}`));
-    } catch (error: any) {
-      output.error(`添加失败: ${error.message}`);
-      process.exit(1);
-    } finally {
-      await envService.dispose();
-    }
-  },
-};