@ai-setting/roy-agent-cli 1.0.0

package/src/commands/interactive.ts

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