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

package/src/commands/interactive.ts

@@ -1,1015 +0,0 @@
-/**
- * @fileoverview Interactive Command
- * 
- * 交互式多轮对话命令 - 复用 act 逻辑
- * 
- * 提供 REPL 风格的多轮对话体验
- * 
- * 特性：
- * - 用户输入与 Assistant 输出颜色区分
- * - Esc 按键：中断流式输出 + 恢复输入（执行中有效，空闲时无操作）
- * - Ctrl+C：任何时候都退出程序
- * - /abort 命令：中断流式输出（与 Esc 等效）
- */
-
-import { CommandModule } from "yargs";
-import * as readline from "readline";
-import chalk from "chalk";
-import { BaseEnvironment } from "@ai-setting/roy-agent-core";
-import { EnvironmentService } from "../services/environment.service";
-import { OutputService } from "../services/output.service";
-import { SessionManager } from "./shared/session-manager";
-import { QueryExecutor } from "./shared/query-executor";
-import { EventHandler } from "./shared/event-handler";
-import { EventMessageFormatter } from "./shared/event-message-formatter";
-import { CliQuietModeService } from "../services/quiet-mode.service";
-import { 
-  COLORS,
-  abortStream, 
-  resetStreamAbort 
-} from "../services/stream-output.service";
-import { createLogger, getTracerProvider } from "@ai-setting/roy-agent-core";
-import { InputHandler } from "./input-handler";
-
-// 创建 cli 模块日志器
-const logger = createLogger("cli:interactive");
-
-export interface InteractiveOptions {
-  session?: string;
-  continue?: boolean;
-  config?: string;
-  reasoning?: boolean;
-  toolCalls?: boolean;
-  toolResults?: boolean;
-  eventSource?: string;  // 启动时一并启动的事件源 ID
-  plugins?: string[];   // 启用的 coder 插件列表，如 ["lsp", "linter", "typecheck"]
-}
-
-// yargs 参数别名映射
-export interface ParsedInteractiveOptions {
-  session?: string;
-  continue?: boolean;
-  config?: string;
-  reasoning?: boolean;
-  toolCalls?: boolean;
-  toolResults?: boolean;
-  eventSource?: string;
-  plugins?: string[];
-}
-
-interface REPLStatus {
-  sessionId: string;
-  sessionTitle: string;
-  messageCount: number;
-  tokenCount: number;
-}
-
-interface REPLOptions {
-  sessionId: string;
-  sessionTitle: string;
-  onExecute: (message: string, traceId?: string) => Promise<string>;
-  onStatus: () => REPLStatus | Promise<REPLStatus>;
-  onSwitchSession: (sessionId: string) => Promise<{ sessionId: string; sessionTitle: string }>;
-  onCompact: () => Promise<void>;
-  onShutdown: () => Promise<void>;  // shutdown 回调，用于清理资源
-}
-
-// 用户输入提示符（带颜色）
-const USER_PROMPT = COLORS.userInput("❯ ");
-
-/**
- * REPL - 简化的 REPL 实现
- */
-export class REPL {
-  private rl: readline.Interface;
-  private options: REPLOptions;
-  private isExecuting = false;
-  private commandRegistry: Map<string, () => Promise<void>> = new Map();
-  private isShuttingDown = false;
-  private env: BaseEnvironment | null = null;
-  private inputHandler: InputHandler;
-
-  constructor(options: REPLOptions, env?: BaseEnvironment) {
-    this.options = options;
-    this.env = env ?? null;
-    this.inputHandler = new InputHandler();
-    
-    this.rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      prompt: USER_PROMPT,
-      historySize: 100,
-    });
-
-    // 注册默认命令
-    this.registerDefaultCommands();
-  }
-
-  /**
-   * 设置环境引用（用于获取 AgentComponent 等组件）
-   */
-  setEnvironment(env: BaseEnvironment): void {
-    this.env = env;
-  }
-
-  /**
-   * 执行优雅关闭
-   * 调用 onShutdown 回调并关闭 readline
-   */
-  async shutdown(): Promise<void> {
-    if (this.isShuttingDown) {
-      return;
-    }
-    this.isShuttingDown = true;
-
-    // 关闭 readline（不再接受输入）
-    this.rl.close();
-
-    // 调用 shutdown 回调执行清理
-    await this.options.onShutdown();
-  }
-
-  private registerDefaultCommands(): void {
-    this.commandRegistry.set("exit", async () => {
-      await this.shutdown();
-      process.exit(0);
-    });
-    this.commandRegistry.set("quit", async () => {
-      await this.shutdown();
-      process.exit(0);
-    });
-    this.commandRegistry.set("q", async () => {
-      await this.shutdown();
-      process.exit(0);
-    });
-
-    this.commandRegistry.set("help", async () => this.printHelp());
-    this.commandRegistry.set("h", async () => this.printHelp());
-
-    this.commandRegistry.set("status", async () => this.printStatus());
-    this.commandRegistry.set("st", async () => this.printStatus());
-
-    this.commandRegistry.set("clear", async () => {
-      console.clear();
-      this.printHeader();
-    });
-    this.commandRegistry.set("cls", async () => {
-      console.clear();
-      this.printHeader();
-    });
-
-    this.commandRegistry.set("sessions", async () => {
-      this.printSessionsHelp();
-    });
-    this.commandRegistry.set("s", async () => this.printSessionsHelp());
-
-    this.commandRegistry.set("compact", async () => {
-      await this.options.onCompact();
-    });
-    this.commandRegistry.set("c", async () => {
-      await this.options.onCompact();
-    });
-
-    // 中断当前请求
-    this.commandRegistry.set("abort", async () => {
-      if (this.isExecuting) {
-        console.log(`\n${COLORS.system("[正在中断...]")}`);
-        
-        // 1. 中断底层 LLM 调用
-        if (this.env) {
-          const agentComponent = this.env.getComponent("agent") as any;
-          if (agentComponent?.abort) {
-            agentComponent.abort("default");
-            logger.debug("[/abort] AgentComponent.abort('default') called");
-          }
-        }
-        
-        // 2. 中断流式输出显示
-        abortStream();
-        
-        // 3. 重置 isExecuting 状态
-        this.isExecuting = false;
-        
-        console.log(`${COLORS.system("[已中断，可以继续输入]")}`);
-      } else {
-        console.log(`\n${COLORS.system("[没有正在执行的请求]")}`);
-      }
-    });
-  }
-
-  async start(): Promise<void> {
-    this.printHeader();
-
-    // 设置 Esc 按键监听
-    readline.emitKeypressEvents(process.stdin);
-    
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode?.(true);
-    }
-
-    // 监听 keypress 事件
-    process.stdin.on("keypress", (str: string, key: readline.Key) => {
-      // Alt+Enter: 结束多行输入
-      if (key.meta && key.name === "return") {
-        // 清除当前行
-        readline.moveCursor(process.stdout, 0, -1);
-        readline.clearLine(process.stdout, 0);
-        this.finishInput();
-        return;
-      }
-
-      // Esc 按键: key.name === "escape"
-      if (key.name === "escape") {
-        this.handleEscKey();
-      }
-    });
-
-    // 返回 Promise，等待 REPL 真正关闭才 resolve
-    return new Promise<void>((resolve) => {
-      this.rl.on("line", async (line) => {
-        await this.handleLine(line.trim());
-      });
-
-      this.rl.on("close", () => {
-        console.log("\n再见！👋\n");
-        resolve();
-      });
-    });
-  }
-
-  private async handleLine(line: string): Promise<void> {
-    // 快捷命令（以 / 开头）- 只有第一行才检测，后续行即使以 / 开头也作为普通文本
-    if (line.startsWith("/") && this.inputHandler.getBuffer() === "") {
-      await this.handleCommand(line.slice(1));
-      this.inputHandler.reset();
-      this.updatePrompt();
-      return;
-    }
-
-    // 累积输入到 buffer（不管是否以 / 开头）
-    this.inputHandler.pushLine(line);
-    this.updatePrompt();
-  }
-
-  /**
-   * 更新 readline 提示符
-   */
-  private updatePrompt(): void {
-    const prompt = this.inputHandler.getPrompt();
-    this.rl.setPrompt(prompt);
-    this.rl.prompt(true);
-  }
-
-  /**
-   * 结束输入，提交 buffer 内容
-   */
-  private finishInput(): void {
-    const fullContent = this.inputHandler.getBuffer();
-    if (!fullContent) {
-      // 空输入，忽略
-      return;
-    }
-
-    // 显示用户输入（带颜色）
-    console.log(COLORS.userInput(`❯ ${fullContent.replace(/\n/g, "\n" + COLORS.userInput("❯ "))}`));
-
-    // 重置 buffer
-    this.inputHandler.reset();
-
-    // 处理消息
-    this.handleMessage(fullContent);
-    this.updatePrompt();
-  }
-
-  private async handleCommand(input: string): Promise<void> {
-    const [cmd] = input.split(/\s+/);
-    const command = this.commandRegistry.get(cmd.toLowerCase());
-
-    if (command) {
-      await command();
-    } else {
-      console.log(`\n${COLORS.error("❓ 未知命令: /" + cmd + "}")}`);
-      this.printHelp();
-    }
-  }
-
-  private async handleMessage(message: string): Promise<void> {
-    if (this.isExecuting) {
-      console.log(`\n${COLORS.system("⏳ 上一次请求尚未完成，请稍候...")}\n`);
-      return;
-    }
-
-    await this.executeInternal(message, { showPrompt: false });
-  }
-
-  /**
-   * 处理事件消息（来自 EventHandler）
-   * 显示为用户输入，并执行 agent
-   */
-  async handleEventMessage(message: string): Promise<void> {
-    // 显示事件消息（带颜色）
-    console.log(`\n${COLORS.system("[通知] ❯ " + message.replace(/\n/g, "\n" + COLORS.system("[通知] ❯ ")))}\n`);
-    await this.executeInternal(message, { showPrompt: true });
-  }
-
-  /**
-   * 检查是否正在执行
-   */
-  isIdle(): boolean {
-    return !this.isExecuting;
-  }
-
-  /**
-   * 执行消息并显示结果（内部实现）
-   */
-  private async executeInternal(
-    message: string, 
-    options: { showPrompt: boolean }
-  ): Promise<void> {
-    this.isExecuting = true;
-    
-    // 重置 abort 信号
-    resetStreamAbort();
-    
-    // 使用 OTelTracer 创建根 span
-    // 关键：在调用 onExecute 之前设置全局 context，这样装饰器创建的 span 也能继承 traceId
-    const provider = getTracerProvider();
-    const tracer = provider.getTracer("roy-tracer");
-    
-    // 创建根 span（会自动设置 currentContext）
-    // 必须在设置全局 context 之前创建，这样全局 context 才能用正确的 spanId
-    const rootSpan = tracer.startSpan("interactive.execute");
-    const traceId = rootSpan.spanContext.traceId;
-    
-    // 设置全局 context，让其他 tracer 实例也能共享这个 traceId
-    // 必须在调用 onExecute 之前设置，这样装饰器创建的 span 才会继承这个 traceId
-    // 使用根 span 的 spanContext 作为全局 context
-    provider.setGlobalContext(rootSpan.spanContext);
-    
-    // 显示 trace id 给用户
-    console.log(`${COLORS.system("[Trace] " + traceId)}`);
-    
-    // 显示思考中提示
-    console.log(`${COLORS.progress("[thinking...]")}`);
-
-    try {
-      // 传递 trace id 给 onExecute
-      await this.options.onExecute(message, traceId);
-      // 注意：流式输出已在 QueryExecutor.subscribeToEvents -> StreamOutputService 中处理
-      // 不需要再次打印返回值，避免重复输出
-    } catch (error) {
-      console.error(`\n${COLORS.error("❌ 执行失败: " + error)}\n`);
-      // 标记 span 为错误
-      rootSpan.setAttribute("error", String(error));
-    } finally {
-      // 清理全局 context（必须在结束 span 之前）
-      provider.setGlobalContext(undefined);
-      
-      // 结束根 span（会保存到 SQLite 并恢复父上下文）
-      rootSpan.end();
-      
-      this.isExecuting = false;
-      // 如果是事件消息，需要恢复 prompt
-      if (options.showPrompt) {
-        this.rl.prompt(true);
-      }
-    }
-  }
-
-  /**
-   * 处理 SIGINT 信号（Ctrl+C）
-   * 
-   * 行为：
-   * - 多行输入中：取消当前输入，重置状态
-   * - 正在执行：退出程序
-   * - 空闲状态：退出程序
-   * 
-   * 与 Esc 的区别：
-   * - Esc：中断 LLM 调用 + 停止流式输出 + 恢复 prompt（继续执行）
-   * - Ctrl+C：退出程序，或取消多行输入
-   */
-  handleSigint(): void {
-    if (this.isShuttingDown) {
-      return;
-    }
-
-    // 多行输入状态下，取消输入而不是退出
-    if (this.inputHandler.getPrompt() !== USER_PROMPT) {
-      console.log("\n\n" + COLORS.system("[已取消多行输入]"));
-      this.inputHandler.reset();
-      this.updatePrompt();
-      return;
-    }
-
-    // 正在执行时，退出程序
-    if (this.isExecuting) {
-      console.log("\n\n收到中断信号，正在清理...");
-      this.shutdown()
-        .then(() => process.exit(0))
-        .catch(() => process.exit(0));
-      return;
-    }
-
-    // 空闲状态，退出程序
-    console.log("\n\n再见！👋\n");
-    this.shutdown()
-      .then(() => process.exit(0))
-      .catch(() => process.exit(0));
-  }
-
-  /**
-   * 处理 Esc 按键 - 中断流式输出
-   * 
-   * Esc 行为：
-   * - 正在执行时：中断底层 LLM 调用 + 停止流式输出 + 恢复 prompt
-   * - 空闲时：不做任何操作
-   * 
-   * 与 Ctrl+C 的区别：
-   * - Esc 只在执行时有效，空闲时不退出
-   * - Ctrl+C 在空闲时会退出程序
-   */
-  handleEscKey(): void {
-    if (this.isShuttingDown) {
-      return;
-    }
-
-    if (this.isExecuting) {
-      // 1. 中断底层 LLM 调用
-      if (this.env) {
-        const agentComponent = this.env.getComponent("agent") as any;
-        if (agentComponent?.abort) {
-          agentComponent.abort("default");
-          logger.debug("[Esc] AgentComponent.abort('default') called");
-        }
-      }
-      
-      // 2. 停止流式输出
-      abortStream();
-      
-      // 3. 重置状态
-      this.isExecuting = false;
-      
-      // 4. 恢复 prompt
-      this.rl.prompt(true);
-    }
-    // 空闲时不做任何操作
-  }
-
-  private printHeader(): void {
-    console.log(chalk.bold("\n╔══════════════════════════════════════════════════╗"));
-    console.log(chalk.bold("║          ") + chalk.green.bold("roy-agent") + chalk.bold(" Interactive Mode") + chalk.bold("              ║"));
-    console.log(chalk.bold("╚══════════════════════════════════════════════════╝\n"));
-    console.log(`${chalk.dim("会话:")} ${this.options.sessionTitle}`);
-    console.log(`${chalk.dim("输入 ")} ${COLORS.userInput("/help")} ${chalk.dim("查看可用命令")}\n`);
-  }
-
-  private printHelp(): void {
-    console.log(`
-${chalk.bold("╭")}${chalk.dim("─".repeat(49))}${chalk.bold("╮")}
-${chalk.bold("│")} ${chalk.bold("快捷命令")}                                     ${chalk.bold("│")}
-${chalk.bold("├")}${chalk.dim("─".repeat(49))}${chalk.bold("├")}
-${chalk.bold("│")}  ${COLORS.userInput("/help")}, ${COLORS.userInput("/h")}    显示帮助                           ${chalk.bold("│")}
-${chalk.bold("│")}  ${COLORS.userInput("/status")}, ${COLORS.userInput("/st")}  显示状态                           ${chalk.bold("│")}
-${chalk.bold("│")}  ${COLORS.userInput("/sessions")}, ${COLORS.userInput("/s")} 切换会话                          ${chalk.bold("│")}
-${chalk.bold("│")}  ${COLORS.userInput("/compact")}, ${COLORS.userInput("/c")} 压缩上下文                         ${chalk.bold("│")}
-${chalk.bold("│")}  ${COLORS.userInput("/abort")}      中断当前流式输出                  ${chalk.bold("│")}
-${chalk.bold("│")}  ${COLORS.userInput("/clear")}, ${COLORS.userInput("/cls")} 清屏                              ${chalk.bold("│")}
-${chalk.bold("│")}  ${COLORS.userInput("/exit")}, ${COLORS.userInput("/q")}   退出                               ${chalk.bold("│")}
-${chalk.bold("├")}${chalk.dim("─".repeat(49))}${chalk.bold("├")}
-${chalk.bold("│")} ${chalk.bold("多行输入")}                                      ${chalk.bold("│")}
-${chalk.bold("├")}${chalk.dim("─".repeat(49))}${chalk.bold("├")}
-${chalk.bold("│")}  输入多行内容后，Alt+Enter 结束输入。       ${chalk.bold("│")}
-${chalk.bold("│")}  Ctrl+C 可取消多行输入。                   ${chalk.bold("│")}
-${chalk.bold("╰")}${chalk.dim("─".repeat(49))}${chalk.bold("╯")}
-`);
-  }
-
-  private async printStatus(): Promise<void> {
-    const status = await this.options.onStatus();
-    console.log(`
-${chalk.bold("╭")}${chalk.dim("─".repeat(49))}${chalk.bold("╮")}
-${chalk.bold("│")}  ${chalk.bold("会话状态")}                                    ${chalk.bold("│")}
-${chalk.bold("├")}${chalk.dim("─".repeat(49))}${chalk.bold("├")}
-${chalk.bold("│")}  ${chalk.dim("会话:")} ${status.sessionTitle.padEnd(35)} ${chalk.bold("│")}
-${chalk.bold("│")}  ${chalk.dim("ID:")} ${status.sessionId.padEnd(37)} ${chalk.bold("│")}
-${chalk.bold("│")}  ${chalk.dim("消息:")} ${String(status.messageCount).padEnd(34)} ${chalk.bold("│")}
-${chalk.bold("│")}  ${chalk.dim("Token:")} ${String(status.tokenCount).padEnd(33)} ${chalk.bold("│")}
-${chalk.bold("╰")}${chalk.dim("─".repeat(49))}${chalk.bold("╯")}
-`);
-  }
-
-  private printSessionsHelp(): void {
-    console.log(`
-${chalk.bold("╭")}${chalk.dim("─".repeat(49))}${chalk.bold("╮")}
-${chalk.bold("│")}  ${chalk.bold("切换会话")}                                    ${chalk.bold("│")}
-${chalk.bold("├")}${chalk.dim("─".repeat(49))}${chalk.bold("├")}
-${chalk.bold("│")}  退出当前交互模式后，使用以下命令切换会话：    ${chalk.bold("│")}
-${chalk.bold("│")}                                                 ${chalk.bold("│")}
-${chalk.bold("│")}  ${COLORS.userInput("roy sessions list")}    列出所有会话          ${chalk.bold("│")}
-${chalk.bold("│")}  ${COLORS.userInput("roy sessions use <id>")} 切换到指定会话       ${chalk.bold("│")}
-${chalk.bold("│")}                                                 ${chalk.bold("│")}
-${chalk.bold("│")}  或直接指定会话启动：                           ${chalk.bold("│")}
-${chalk.bold("│")}  ${COLORS.userInput("roy interactive -s <session-id>")}            ${chalk.bold("│")}
-${chalk.bold("╰")}${chalk.dim("─".repeat(49))}${chalk.bold("╯")}
-`);
-  }
-}
-
-/**
- * InteractiveCommand - 交互式命令
- * 
- * 核心复用：
- * - SessionManager: Session 管理
- * - QueryExecutor: 查询执行
- * - REPL: 交互循环
- */
-export const InteractiveCommand: CommandModule<object, InteractiveOptions> = {
-  command: "interactive",
-  aliases: ["i", "repl"],
-  describe: "交互式模式 - 多轮对话交互",
-
-  builder: (yargs) =>
-    yargs
-      .option("session", {
-        alias: "s",
-        describe: "指定会话 ID",
-        type: "string",
-      })
-      .option("continue", {
-        alias: "c",
-        describe: "继续上次会话",
-        type: "boolean",
-        default: false,
-      })
-      .option("config", {
-        alias: "C",
-        describe: "配置文件路径",
-        type: "string",
-      })
-      .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("event-source", {
-        alias: "es",
-        describe: "启动时一并启动的事件源 ID",
-        type: "string",
-      })
-      .option("plugin", {
-        alias: "p",
-        describe: "启用 plugin (lsp, code-check, reminder, memory, task-tag)",
-        type: "array",
-        string: true,
-      }),
-
-  async handler(args) {
-    // ========== 1. 初始化（复用 act） ==========
-    CliQuietModeService.getInstance().setQuiet(true);
-    const output = new OutputService();
-    const envService = new EnvironmentService(output);
-
-    // ========== 1.5 Plugin 参数解析（与 act.ts 保持一致）==========
-    // coder-harness 插件名称集合
-    const CODER_HARNESS_PLUGINS = new Set(["lsp", "code-check", "reminder"]);
-    
-    // 确保 plugins 是数组（yargs 在单个值时可能返回字符串）
-    const rawPlugins = args.plugin;
-    const pluginNames: string[] = Array.isArray(rawPlugins)
-      ? rawPlugins
-      : rawPlugins
-        ? [rawPlugins]
-        : [];
-
-    // 分离 coder-harness 插件和 component plugins
-    const coderPluginNames: string[] = [];
-    const componentPluginNames: string[] = [];
-
-    for (const plugin of pluginNames) {
-      const name = plugin.split(":")[0];
-      if (CODER_HARNESS_PLUGINS.has(name)) {
-        coderPluginNames.push(plugin);
-      } else {
-        componentPluginNames.push(plugin);
-      }
-    }
-
-    try {
-      // 创建环境（传入 componentPluginNames 以加载 task-tag 等插件）
-      await envService.create({ 
-        configPath: args.config,
-        plugins: componentPluginNames,
-      });
-      const env = envService.getEnvironment();
-      if (!env) {
-        output.error("Failed to create environment");
-        process.exit(1);
-      }
-      const sessionComponent = envService.getSession();
-      if (!sessionComponent) {
-        output.error("Failed to create session component");
-        process.exit(1);
-      }
-
-      // 初始化 SummaryAgent（复用 act 逻辑）
-      const llmComponent = envService.getLLM();
-      const promptComponent = env.getComponent("prompt") as any;
-
-      // 初始化流式输出服务（导入 COLORS 和 abort 函数）
-      const { COLORS: STREAM_COLORS, resetStreamAbort: resetStream } = await import("../services/stream-output.service");
-
-      // ========== 2. Session 管理（复用 SessionManager） ==========
-      const sessionManager = new SessionManager({
-        sessionComponent,
-        output,
-        quiet: true,
-      });
-
-      const sessionResult = await sessionManager.init(args.session, args.continue);
-      const { sessionId, sessionTitle } = sessionResult;
-
-      if (llmComponent && promptComponent) {
-        sessionComponent.setSummaryComponents(promptComponent, llmComponent);
-      }
-
-      // ========== 3. Query 执行器（复用 QueryExecutor） ==========
-      const queryExecutor = new QueryExecutor({
-        env,
-        sessionComponent,
-        output,
-        quiet: true,
-      });
-
-      // 初始化流式输出配置（设置 context window 信息）
-      queryExecutor.initStreamOutput(llmComponent);
-
-      // ========== 3.5 Coder-harness 插件加载（lsp/linter/typecheck）==========
-      // 延迟加载 coder-harness 以避免影响 CLI 基础功能
-      let pluginAdapterDispose: (() => Promise<void>) | null = null;
-      let lspManagerDispose: (() => Promise<void>) | null = null;
-      let memoryPluginDispose: (() => Promise<void>) | null = null;
-      // MemoryPlugin 实例（用于 shutdown 时访问）
-      let memoryPluginInstance: any = null;
-
-      // Coder-harness 插件加载（lsp/linter/typecheck）
-      if (coderPluginNames.length > 0) {
-        try {
-          // 使用 globalHookManager（与 act.ts 保持一致）
-          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 预加载等）- 与 act.ts 保持一致
-          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(", ")}`);
-          }
-
-          // ========== 3.6 Memory Plugin 加载 ==========
-          // MemoryPlugin 已在 EnvironmentService 中创建并传入 MemoryComponent
-          // 这里只需要注册到 AgentComponent 的 Hook 系统
-          if (coderPluginNames.includes("memory")) {
-            try {
-              // 从 EnvironmentService 获取已创建的 MemoryPlugin 实例
-              const memoryPluginInstance = (envService as any).getMemoryPlugin?.();
-              
-              if (memoryPluginInstance) {
-                // 注册到 AgentComponent（使用 default agent）
-                const agentComponent = env.getComponent("agent") as any;
-                if (agentComponent?.registerPlugin) {
-                  // 确保 default agent 存在（可能在 queryExecutor.execute 之前调用）
-                  if (!agentComponent.getAgent("default")) {
-                    agentComponent.registerAgent("default", { type: "primary" });
-                  }
-                  
-                  // 创建符合 Plugin 接口的对象
-                  const pluginWrapper = {
-                    name: memoryPluginInstance.name,
-                    version: "1.0.0",
-                    hooks: memoryPluginInstance.hooks,
-                    execute: async (ctx: any) => {
-                      await memoryPluginInstance.execute(ctx);
-                      return { continue: true };
-                    },
-                  };
-                  agentComponent.registerPlugin("default", pluginWrapper);
-                  output.success("✅ Memory 插件已注册到 Agent");
-                }
-                
-                // 设置 dispose 函数
-                memoryPluginDispose = async () => {
-                  if (memoryPluginInstance) {
-                    memoryPluginInstance.prepareShutdown();
-                    if (memoryPluginInstance.hasPendingTasks()) {
-                      console.log("💾 正在保存记忆，请稍候...");
-                      await memoryPluginInstance.waitForCompletion();
-                    }
-                    await memoryPluginInstance.dispose();
-                    console.log("💾 记忆已保存完毕");
-                  }
-                };
-              } else {
-                output.warn("⚠️ Memory 插件未在 EnvironmentService 中初始化");
-              }
-            } catch (error) {
-              output.warn(`⚠️ Memory 插件加载失败: ${error}`);
-            }
-          }
-
-              // ========== 3.7 LSP Plugin 加载 ==========
-          // 如果启用了 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();
-
-              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();
-              // 预热所有服务器（异步，不阻塞）
-              if (lspConfig.preload || coderPluginNames.includes("lsp")) {
-                lspManager.prewarm().then(() => {
-                  output.success("✅ LSP 服务器预热完成");
-                }).catch((err: Error) => {
-                  output.warn(`⚠ LSP 预热部分失败: ${err.message}`);
-                });
-              }
-            } catch (error) {
-              output.warn(`⚠ LSP 预热失败: ${error}`);
-            }
-          }
-        } catch (error) {
-          output.error(`❌ 加载 coder-harness 插件失败: ${error}`);
-        }
-      }
-
-      // ========== 4. REPL 循环（新增） ==========
-      // 传入 env 引用，以便在 Ctrl+C 时可以获取 AgentComponent 进行中断
-      const repl = new REPL({
-        sessionId,
-        sessionTitle,
-        onExecute: async (message: string, traceId?: string) => {
-          // 每次执行前重置 abort 信号
-          resetStreamAbort();
-          return queryExecutor.execute(message, sessionId, {
-            showReasoning: args.reasoning,
-            showToolCalls: args.toolCalls,
-            showToolResults: args.toolResults,
-          }, traceId);
-        },
-        onStatus: async (): Promise<REPLStatus> => {
-          // 从 session 获取真实统计
-          const session = await sessionComponent.get(sessionId);
-          return {
-            sessionId,
-            sessionTitle,
-            messageCount: session?.messageCount ?? 0,
-            tokenCount: 0, // tokenCount 需要从消息中累加，暂不实现
-          };
-        },
-        onSwitchSession: async (newSessionId: string) => {
-          const result = await sessionManager.switchSession(newSessionId);
-          queryExecutor.dispose();
-          return result;
-        },
-        onCompact: async () => {
-          output.info("🔄 正在压缩上下文...");
-          const result = await queryExecutor.compact(sessionId);
-          if (result.success) {
-            output.success(`✓ 压缩完成，清理了 ${result.deletedMessageCount} 条消息`);
-          } else {
-            output.error(`❌ 压缩失败: ${result.error}`);
-          }
-        },
-        onShutdown: async () => {
-          // 0. 清理 MemoryPlugin（等待待处理任务完成）
-          if (memoryPluginDispose) {
-            if (memoryPluginInstance && memoryPluginInstance.hasPendingTasks()) {
-              console.log("💾 正在保存记忆，请稍候...");
-              await memoryPluginInstance.waitForCompletion();
-            }
-            await memoryPluginDispose();
-            console.log("💾 记忆已保存完毕");
-          }
-          
-          // 1. 清理 LSP Manager（关闭所有 LSP 连接和进程）
-          if (lspManagerDispose) {
-            await lspManagerDispose();
-          }
-          
-          // 2. 清理 PluginAdapter
-          if (pluginAdapterDispose) {
-            await pluginAdapterDispose();
-          }
-          
-          // 2. 停止 EventHandler
-          eventHandler.stop();
-          
-          // 2. 停止 QueryExecutor（取消环境事件订阅）
-          queryExecutor.dispose();
-          
-          // 3. 停止所有运行中的事件源
-          const eventSourceComponent = env.getComponent("event-source") as any;
-          if (eventSourceComponent) {
-            const sources = eventSourceComponent.list?.();
-            if (sources && sources.length > 0) {
-              for (const source of sources) {
-                const status = eventSourceComponent.getStatus?.(source.id);
-                logger.debug(`[Shutdown] 检查事件源: ${source.id}, 状态: ${status}`);
-                
-                // 停止任何非 stopped 状态的事件源（包括 running 和 error）
-                if (status !== "stopped" && status !== "created") {
-                  try {
-                    await eventSourceComponent.stopSource(source.id);
-                    output.info(`✓ 已停止事件源: ${source.name} (${status})`);
-                  } catch (error) {
-                    output.warn(`⚠️ 停止事件源 ${source.name} 失败: ${error}`);
-                  }
-                }
-              }
-            }
-          }
-          
-          // 4. 销毁环境
-          await envService.dispose();
-        },
-      }, env);
-
-      // ========== 5. EventHandler（事件驱动自动响应） ==========
-      const eventHandler = new EventHandler({
-        env,
-        eventTypes: ["task.*", "event-source.event.*"],  // 只监听任务事件和事件源的实际消息事件
-        formatter: new EventMessageFormatter({ prefix: "[通知]" }),
-        isIdle: () => repl.isIdle(),
-        onEvent: async (message: string) => {
-          await repl.handleEventMessage(message);
-        },
-      });
-      
-      // 启动事件监听
-      const stopEventHandler = eventHandler.start();
-
-      // ========== 6. EventSource 启动（必须成功） ==========
-      const eventSourceId = args.eventSource;
-      let eventSourceStarted = false;
-      
-      if (eventSourceId) {
-        const eventSourceComponent = env.getComponent("event-source") as any;
-        
-        if (!eventSourceComponent || typeof eventSourceComponent.startSource !== "function") {
-          output.error(`❌ 未找到事件源组件或 startSource 方法`);
-          output.info(`请确保 EventSourceComponent 已正确注册`);
-          process.exit(1);
-        }
-        
-        // 支持前缀匹配
-        const sources = eventSourceComponent.list();
-        const matchedSource = sources.find(
-          (s: any) => s.id === eventSourceId || s.id.startsWith(eventSourceId)
-        );
-        
-        if (!matchedSource) {
-          output.error(`❌ 事件源不存在: ${eventSourceId}`);
-          output.info(`可用的事件源:`);
-          for (const s of sources) {
-            output.info(`  - ${s.id}: ${s.name} (${s.type})`);
-          }
-          process.exit(1);
-        }
-        
-        const actualId = matchedSource.id;
-        const status = eventSourceComponent.getStatus(actualId);
-        
-        if (status === "running") {
-          output.info(`📡 事件源 ${matchedSource.name} 已在运行中`);
-        } else {
-          try {
-            await eventSourceComponent.startSource(actualId);
-            
-            // 验证启动成功：检查状态是否为 running
-            const verifyStatus = eventSourceComponent.getStatus(actualId);
-            if (verifyStatus !== "running") {
-              output.error(`❌ 事件源启动后状态异常: ${verifyStatus}`);
-              output.info(`请检查日志确认后台进程是否正常运行`);
-              process.exit(1);
-            }
-            
-            eventSourceStarted = true;
-            output.success(`📡 已启动事件源: ${matchedSource.name} (${verifyStatus})`);
-          } catch (error) {
-            output.error(`❌ 启动事件源失败: ${error}`);
-            output.info(`常见问题:`);
-            output.info(`  - lark-cli 事件源：确保已安装并登录 lark-cli`);
-            output.info(`  - websocket 事件源：确保目标服务器可达`);
-            output.info(`  - timer 事件源：检查配置是否正确`);
-            process.exit(1);
-          }
-        }
-      }
-
-      // ========== 7. SIGINT 处理器（Ctrl+C）==========
-      // 不再使用 process.on("SIGINT")，改用 REPL.handleSigint()
-      // 需要在启动 REPL 之前设置信号处理
-      let sigintHandler: NodeJS.SignalsListener;
-
-      // 创建一个可以被移除的 handler
-      sigintHandler = () => {
-        repl.handleSigint();
-      };
-      
-      process.on("SIGINT", sigintHandler);
-
-      // 启动 REPL
-      await repl.start();
-
-      // 移除 SIGINT 处理器（正常退出时）
-      process.removeListener("SIGINT", sigintHandler);
-
-      // ========== 清理（正常退出） ==========
-      // 注意：exit 命令会调用 shutdown，然后 process.exit
-      // 正常退出时（REPL 自然关闭），需要手动清理
-      console.log("正在清理资源...");
-
-      // 0. 清理 LSP Manager（关闭所有 LSP 连接和进程）
-      if (lspManagerDispose) {
-        await lspManagerDispose();
-      }
-
-      // 1. 清理 PluginAdapter
-      if (pluginAdapterDispose) {
-        await pluginAdapterDispose();
-      }
-
-      // 2. 停止 EventHandler
-      eventHandler.stop();
-
-      // 停止 QueryExecutor
-      queryExecutor.dispose();
-
-      // 停止所有运行中的事件源
-      const esComponent = env.getComponent("event-source") as any;
-      if (esComponent) {
-        const sources = esComponent.list?.();
-        if (sources) {
-          for (const source of sources) {
-            const status = esComponent.getStatus?.(source.id);
-            if (status === "running") {
-              try {
-                await esComponent.stopSource(source.id);
-                output.info(`✓ 已停止事件源: ${source.name}`);
-              } catch (error) {
-                output.warn(`⚠️ 停止事件源 ${source.name} 失败: ${error}`);
-              }
-            }
-          }
-        }
-      }
-
-      // 销毁环境
-      await envService.dispose();
-
-    } catch (error) {
-      output.error(`启动交互模式失败: ${error}`);
-      throw error;
-    } finally {
-      await envService.dispose();
-    }
-  },
-};