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

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

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