@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/cli/src/commands/interactive.js

@@ -0,0 +1,854 @@
+/**
+ * @fileoverview Interactive Command
+ *
+ * 交互式多轮对话命令 - 复用 act 逻辑
+ *
+ * 提供 REPL 风格的多轮对话体验
+ *
+ * 特性：
+ * - 用户输入与 Assistant 输出颜色区分
+ * - Esc 按键：中断流式输出 + 恢复输入（执行中有效，空闲时无操作）
+ * - Ctrl+C：任何时候都退出程序
+ * - /abort 命令：中断流式输出（与 Esc 等效）
+ */
+import * as readline from "readline";
+import chalk from "chalk";
+import { EnvironmentService } from "../services/environment.service.js";
+import { OutputService } from "../services/output.service.js";
+import { SessionManager } from "./shared/session-manager.js";
+import { QueryExecutor } from "./shared/query-executor.js";
+import { EventHandler } from "./shared/event-handler.js";
+import { EventMessageFormatter } from "./shared/event-message-formatter.js";
+import { CliQuietModeService } from "../services/quiet-mode.service.js";
+import { COLORS, abortStream, resetStreamAbort } from "../services/stream-output.service.js";
+import { createLogger, getTracerProvider } from "@ai-setting/roy-agent-core";
+import { InputHandler } from "./input-handler.js";
+// 创建 cli 模块日志器
+const logger = createLogger("cli:interactive");
+// 用户输入提示符（带颜色）
+const USER_PROMPT = COLORS.userInput("❯ ");
+/**
+ * REPL - 简化的 REPL 实现
+ */
+export class REPL {
+    rl;
+    options;
+    isExecuting = false;
+    commandRegistry = new Map();
+    isShuttingDown = false;
+    env = null;
+    inputHandler;
+    constructor(options, env) {
+        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) {
+        this.env = env;
+    }
+    /**
+     * 执行优雅关闭
+     * 调用 onShutdown 回调并关闭 readline
+     */
+    async shutdown() {
+        if (this.isShuttingDown) {
+            return;
+        }
+        this.isShuttingDown = true;
+        // 关闭 readline（不再接受输入）
+        this.rl.close();
+        // 调用 shutdown 回调执行清理
+        await this.options.onShutdown();
+    }
+    registerDefaultCommands() {
+        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");
+                    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() {
+        this.printHeader();
+        // 设置 Esc 按键监听
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode?.(true);
+        }
+        // 监听 keypress 事件
+        process.stdin.on("keypress", (str, 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((resolve) => {
+            this.rl.on("line", async (line) => {
+                await this.handleLine(line.trim());
+            });
+            this.rl.on("close", () => {
+                console.log("\n再见！👋\n");
+                resolve();
+            });
+        });
+    }
+    async handleLine(line) {
+        // 快捷命令（以 / 开头）- 只有第一行才检测，后续行即使以 / 开头也作为普通文本
+        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 提示符
+     */
+    updatePrompt() {
+        const prompt = this.inputHandler.getPrompt();
+        this.rl.setPrompt(prompt);
+        this.rl.prompt(true);
+    }
+    /**
+     * 结束输入，提交 buffer 内容
+     */
+    finishInput() {
+        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();
+    }
+    async handleCommand(input) {
+        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();
+        }
+    }
+    async handleMessage(message) {
+        if (this.isExecuting) {
+            console.log(`\n${COLORS.system("⏳ 上一次请求尚未完成，请稍候...")}\n`);
+            return;
+        }
+        await this.executeInternal(message, { showPrompt: false });
+    }
+    /**
+     * 处理事件消息（来自 EventHandler）
+     * 显示为用户输入，并执行 agent
+     */
+    async handleEventMessage(message) {
+        // 显示事件消息（带颜色）
+        console.log(`\n${COLORS.system("[通知] ❯ " + message.replace(/\n/g, "\n" + COLORS.system("[通知] ❯ ")))}\n`);
+        await this.executeInternal(message, { showPrompt: true });
+    }
+    /**
+     * 检查是否正在执行
+     */
+    isIdle() {
+        return !this.isExecuting;
+    }
+    /**
+     * 执行消息并显示结果（内部实现）
+     */
+    async executeInternal(message, options) {
+        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() {
+        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() {
+        if (this.isShuttingDown) {
+            return;
+        }
+        if (this.isExecuting) {
+            // 1. 中断底层 LLM 调用
+            if (this.env) {
+                const agentComponent = this.env.getComponent("agent");
+                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);
+        }
+        // 空闲时不做任何操作
+    }
+    printHeader() {
+        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`);
+    }
+    printHelp() {
+        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("╯")}
+`);
+    }
+    async printStatus() {
+        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("╯")}
+`);
+    }
+    printSessionsHelp() {
+        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 = {
+    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 = Array.isArray(rawPlugins)
+            ? rawPlugins
+            : rawPlugins
+                ? [rawPlugins]
+                : [];
+        // 分离 coder-harness 插件和 component plugins
+        const coderPluginNames = [];
+        const componentPluginNames = [];
+        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");
+            // 初始化流式输出服务（导入 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 = null;
+            let lspManagerDispose = null;
+            let memoryPluginDispose = null;
+            // MemoryPlugin 实例（用于 shutdown 时访问）
+            let memoryPluginInstance = 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, {
+                        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.getMemoryPlugin?.();
+                            if (memoryPluginInstance) {
+                                // 注册到 AgentComponent（使用 default agent）
+                                const agentComponent = env.getComponent("agent");
+                                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) => {
+                                            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) => {
+                                    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, traceId) => {
+                    // 每次执行前重置 abort 信号
+                    resetStreamAbort();
+                    return queryExecutor.execute(message, sessionId, {
+                        showReasoning: args.reasoning,
+                        showToolCalls: args.toolCalls,
+                        showToolResults: args.toolResults,
+                    }, traceId);
+                },
+                onStatus: async () => {
+                    // 从 session 获取真实统计
+                    const session = await sessionComponent.get(sessionId);
+                    return {
+                        sessionId,
+                        sessionTitle,
+                        messageCount: session?.messageCount ?? 0,
+                        tokenCount: 0, // tokenCount 需要从消息中累加，暂不实现
+                    };
+                },
+                onSwitchSession: async (newSessionId) => {
+                    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");
+                    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) => {
+                    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");
+                if (!eventSourceComponent || typeof eventSourceComponent.startSource !== "function") {
+                    output.error(`❌ 未找到事件源组件或 startSource 方法`);
+                    output.info(`请确保 EventSourceComponent 已正确注册`);
+                    process.exit(1);
+                }
+                // 支持前缀匹配
+                const sources = eventSourceComponent.list();
+                const matchedSource = sources.find((s) => 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;
+            // 创建一个可以被移除的 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");
+            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();
+        }
+    },
+};
+//# sourceMappingURL=interactive.js.map