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

package/dist/bin/roy.js

@@ -112340,7 +112340,7 @@ var init_stream_output_service = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@ai-setting/roy-agent-cli",
-    version: "1.3.15",
+    version: "1.3.16",
     description: "CLI for roy-agent - Non-interactive command execution",
     type: "module",
     bin: {
@@ -112384,7 +112384,8 @@ var require_package = __commonJS((exports, module) => {
       dev: "bun run src/bin/roy.ts",
       test: "bun test",
       cli: "bun run src/bin/roy.ts",
-      prepublishOnly: "PRODUCTION=1 bun run scripts/build.ts --skip-install"
+      prepublishOnly: "PRODUCTION=1 bun run scripts/build.ts --skip-install",
+      "npm-publish": "bun run scripts/build.ts --npm-publish"
     },
     dependencies: {
       "@ai-setting/roy-agent-coder-harness": "workspace:*",
@@ -127294,4 +127295,4 @@ runCli().catch((error41) => {
   process.exit(1);
 });
 
-//# debugId=4BB421EB881FB62664756E2164756E21
+//# debugId=9343921D1DDC5BB364756E2164756E21

package/dist/cli/src/bin/roy.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * @roy-agent/cli - CLI entry point
+ */
+export {};
+//# sourceMappingURL=roy.d.ts.map

package/dist/cli/src/bin/roy.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * @roy-agent/cli - CLI entry point
+ */
+import { runCli } from "../cli.js";
+runCli().catch((error) => {
+    console.error("Error:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=roy.js.map

package/dist/cli/src/cli.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview CLI Main Entry
+ */
+export declare function runCli(): Promise<void>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli/src/cli.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview CLI Main Entry
+ */
+// @ts-ignore - yargs types issue with bundler module resolution
+import yargsLib from "yargs";
+import { hideBin } from "yargs/helpers";
+import { CliQuietModeService } from "./services/quiet-mode.service.js";
+import { ActCommand } from "./commands/act.js";
+import { InteractiveCommand } from "./commands/interactive.js";
+import { SessionsCommand } from "./commands/sessions/index.js";
+import { TasksCommand } from "./commands/tasks/index.js";
+import { SkillsCommand } from "./commands/skills/index.js";
+import { CommandsCommand } from "./commands/commands.js";
+import { ConfigCommand } from "./commands/config/index.js";
+import { McpCommand } from "./commands/mcp/index.js";
+import { ToolsCommand } from "./commands/tools/index.js";
+import { MemoryCommand } from "./commands/memory/index.js";
+import { EventSourceCommand } from "./commands/eventsource/index.js";
+import { DebugCommand } from "./commands/debug/index.js";
+import { WorkflowCommand } from "./commands/workflow/index.js";
+import { LspCommand } from "./commands/lsp/index.js";
+/**
+ * 全局 quiet 模式 middleware
+ *
+ * 使用统一的 CliQuietModeService 管理 quiet 模式状态
+ * 与 LogTraceComponent 的 setQuietMode 机制保持一致
+ */
+function quietModeMiddleware(argv) {
+    const quietService = CliQuietModeService.getInstance();
+    quietService.setQuietFromArgv(argv);
+}
+/**
+ * Plugin 帮助信息
+ */
+const PLUGIN_HELP = `
+Plugins:
+  coder-harness plugins:
+    lsp         LSP code intelligence (diagnostics, completions)
+    code-check  External command code checking (linter + type check)
+    reminder    Max iterations reminder for ReAct loop
+
+  component plugins:
+    task-tag    Task tag suggestion and similar task experience
+
+Examples:
+  --plugin lsp                   Enable LSP plugin
+  --plugin code-check            Enable external command checking
+  --plugin reminder              Enable iteration reminder
+  --plugin lsp code-check reminder  Enable multiple coder plugins
+  --plugin task-tag              Enable task-tag plugin
+  --plugin task-tag lsp          Enable both plugins`;
+export async function runCli() {
+    const pkg = await import("../package.json", { with: { type: "json" } });
+    // @ts-ignore - yargs types issue
+    const yargs = yargsLib;
+    await yargs(hideBin(process.argv))
+        .scriptName("roy")
+        .version(pkg.default.version)
+        // 全局 quiet 选项
+        .option("quiet", {
+        alias: "q",
+        type: "boolean",
+        description: "Suppress all log output",
+        global: true, // 所有子命令都继承此选项
+    })
+        // 全局 plugin 选项
+        .option("plugin", {
+        alias: "p",
+        type: "string",
+        array: true,
+        description: "Enable plugin (e.g., --plugin lsp, --plugin task-tag)",
+        global: true,
+    })
+        // 全局 middleware，在命令执行前设置 quiet 模式
+        .middleware(quietModeMiddleware, true)
+        .command(ActCommand)
+        .command(InteractiveCommand)
+        .command(SessionsCommand)
+        .command(TasksCommand)
+        .command(SkillsCommand)
+        .command(CommandsCommand)
+        .command(ConfigCommand)
+        .command(McpCommand)
+        .command(ToolsCommand)
+        .command(MemoryCommand)
+        .command(EventSourceCommand)
+        .command(DebugCommand)
+        .command(WorkflowCommand)
+        .command(LspCommand)
+        .demandCommand()
+        .help()
+        .alias("help", "h")
+        .epilog(PLUGIN_HELP)
+        .parse();
+}
+//# sourceMappingURL=cli.js.map

package/dist/cli/src/commands/act.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Act Command
+ *
+ * 自然语言交互命令 - CLI 核心命令
+ *
+ * 功能：
+ * - 支持在指定 session 上继续对话（--session）
+ * - 支持继续上次会话（--continue）
+ * - 支持上下文阈值自动压缩
+ */
+import { CommandModule } from "yargs";
+export interface ActOptions {
+    message?: string;
+    continue?: boolean;
+    session?: string;
+    model?: string;
+    env?: string;
+    config?: string;
+    quiet?: boolean;
+    reasoning?: boolean;
+    toolCalls?: boolean;
+    toolResults?: boolean;
+    plugins?: string[];
+}
+/**
+ * ActCommand - 自然语言交互命令
+ *
+ * 通过自然语言驱动整个操作系统
+ *
+ * @example
+ * # 在指定 session 上继续对话
+ * roy act "继续开发" --session s_abc123
+ *
+ * # 继续上次会话
+ * roy act "继续" --continue
+ *
+ * # 组合使用
+ * roy act "继续" --continue --reasoning
+ *
+ * # 启用 coder 插件
+ * roy act "帮我重构这段代码" --plugin lsp --plugin code-check --plugin reminder
+ */
+export declare const ActCommand: CommandModule<object, ActOptions>;
+//# sourceMappingURL=act.d.ts.map

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

@@ -0,0 +1,415 @@
+/**
+ * @fileoverview Act Command
+ *
+ * 自然语言交互命令 - CLI 核心命令
+ *
+ * 功能：
+ * - 支持在指定 session 上继续对话（--session）
+ * - 支持继续上次会话（--continue）
+ * - 支持上下文阈值自动压缩
+ */
+import { EnvironmentService } from "../services/environment.service.js";
+import { OutputService } from "../services/output.service.js";
+import { StreamOutputService } from "../services/stream-output.service.js";
+import { ContextHandlerService } from "../services/context-handler.service.js";
+import { ContextError, ErrorCodes, getTracerProvider } from "@ai-setting/roy-agent-core";
+import { CliQuietModeService } from "../services/quiet-mode.service.js";
+/**
+ * 生成唯一的 trace ID
+ */
+function generateTraceId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 10);
+    return `req_${timestamp}_${random}`;
+}
+/**
+ * ActCommand - 自然语言交互命令
+ *
+ * 通过自然语言驱动整个操作系统
+ *
+ * @example
+ * # 在指定 session 上继续对话
+ * roy act "继续开发" --session s_abc123
+ *
+ * # 继续上次会话
+ * roy act "继续" --continue
+ *
+ * # 组合使用
+ * roy act "继续" --continue --reasoning
+ *
+ * # 启用 coder 插件
+ * roy act "帮我重构这段代码" --plugin lsp --plugin code-check --plugin reminder
+ */
+export const ActCommand = {
+    command: "act [message]",
+    describe: "自然语言交互 - 通过自然语言驱动整个操作系统",
+    builder: (yargs) => yargs
+        .positional("message", {
+        describe: "要执行的消息",
+        type: "string",
+    })
+        .option("continue", {
+        alias: "c",
+        describe: "继续上次会话",
+        type: "boolean",
+        default: false,
+    })
+        .option("session", {
+        alias: "s",
+        describe: "指定会话 ID",
+        type: "string",
+    })
+        .option("model", {
+        describe: "使用的模型",
+        type: "string",
+    })
+        .option("config", {
+        alias: "C",
+        describe: "配置文件路径",
+        type: "string",
+    })
+        .option("quiet", {
+        alias: "q",
+        describe: "安静模式：只输出最终结果（默认开启）",
+        type: "boolean",
+        default: true,
+    })
+        .option("reasoning", {
+        alias: "r",
+        describe: "显示 AI 思考过程",
+        type: "boolean",
+        default: false,
+    })
+        .option("tool-calls", {
+        describe: "显示工具调用",
+        type: "boolean",
+        default: false,
+    })
+        .option("tool-results", {
+        describe: "显示工具执行结果",
+        type: "boolean",
+        default: false,
+    })
+        .option("plugin", {
+        alias: "p",
+        describe: "启用 coder plugin (lsp, code-check, reminder)",
+        type: "array",
+        string: true,
+    }),
+    async handler(args) {
+        // 设置日志 quiet 模式
+        const quiet = args.quiet ?? true;
+        CliQuietModeService.getInstance().setQuiet(quiet);
+        const output = new OutputService();
+        output.configure({ quiet });
+        // 验证消息
+        if (!args.message) {
+            output.error("请提供要执行的消息，使用方式：roy act <消息>");
+            output.info("示例：roy act \"帮我写一个 hello world\"");
+            process.exit(1);
+        }
+        const envService = new EnvironmentService(output);
+        // Plugin adapter dispose 函数（需要在 finally 中调用）
+        let pluginAdapterDispose = null;
+        // LSP Manager dispose 函数
+        let lspManagerDispose = null;
+        // ========== 解析插件参数 ==========
+        const rawPlugins = args.plugin;
+        const pluginNames = Array.isArray(rawPlugins)
+            ? rawPlugins
+            : rawPlugins
+                ? [rawPlugins]
+                : [];
+        // coder-harness 插件名称集合
+        const CODER_HARNESS_PLUGINS = new Set(["lsp", "code-check", "reminder"]);
+        // 分离 coder-harness 插件和其他插件
+        const coderPluginNames = [];
+        const otherPluginNames = [];
+        for (const plugin of pluginNames) {
+            const name = plugin.split(":")[0];
+            if (CODER_HARNESS_PLUGINS.has(name)) {
+                coderPluginNames.push(plugin);
+            }
+            else {
+                otherPluginNames.push(plugin);
+            }
+        }
+        // 日志输出加载的插件
+        if (otherPluginNames.length > 0 && !quiet) {
+            output.info(`📌 加载插件: ${otherPluginNames.join(", ")}`);
+        }
+        try {
+            if (!quiet) {
+                output.info("初始化环境...");
+            }
+            // 创建环境
+            await envService.create({
+                envName: args.env,
+                configPath: args.config,
+                plugins: [...otherPluginNames, ...coderPluginNames],
+            });
+            const env = envService.getEnvironment();
+            const sessionComponent = envService.getSession();
+            if (!sessionComponent) {
+                output.error("SessionComponent not available");
+                process.exit(1);
+            }
+            // ========== Session 处理 ==========
+            let sessionId = args.session;
+            let isNewSession = false;
+            // 如果指定了 --continue，获取上次会话
+            if (args.continue && !sessionId) {
+                const activeSession = await sessionComponent.getActiveSession();
+                if (activeSession) {
+                    sessionId = activeSession.id;
+                    if (!quiet) {
+                        output.info(`继续会话: ${activeSession.title} (${sessionId})`);
+                    }
+                }
+                else {
+                    output.warn("没有找到上次会话，将创建新会话");
+                }
+            }
+            // 如果指定了 session，设置为 active 并获取会话信息
+            if (sessionId) {
+                await sessionComponent.setActiveSession(sessionId);
+                const session = await sessionComponent.get(sessionId);
+                if (session) {
+                    if (!quiet) {
+                        output.info(`会话: ${session.title} (${sessionId})`);
+                    }
+                }
+                else {
+                    output.warn(`会话不存在: ${sessionId}，将创建新会话`);
+                    sessionId = undefined;
+                }
+            }
+            // 如果没有 session，创建一个新会话
+            if (!sessionId) {
+                const newSession = await sessionComponent.create({
+                    title: `Session - ${new Date().toLocaleString("zh-CN")}`,
+                });
+                sessionId = newSession.id;
+                isNewSession = true;
+                await sessionComponent.setActiveSession(sessionId);
+                if (!quiet) {
+                    output.info(`创建新会话: ${newSession.title} (${sessionId})`);
+                }
+            }
+            // 初始化 SummaryAgent（用于 compact）
+            const llmComponent = envService.getLLM();
+            if (!env) {
+                output.error("Environment not available");
+                process.exit(1);
+            }
+            const promptComponent = env.getComponent("prompt");
+            if (llmComponent && promptComponent) {
+                sessionComponent.setSummaryComponents(promptComponent, llmComponent);
+            }
+            // ========== Plugin 加载（coder-harness 插件） ==========
+            // 组件插件已通过 envService.create 加载
+            if (coderPluginNames.length > 0) {
+                try {
+                    // 使用 globalHookManager（ToolComponent 内部使用）
+                    const { globalHookManager } = await import("@ai-setting/roy-agent-core");
+                    const { createPluginHookAdapter, createGlobalLSPManager } = await import("@ai-setting/roy-agent-coder-harness");
+                    const adapter = createPluginHookAdapter(globalHookManager, {
+                        enableLSP: coderPluginNames.includes("lsp"),
+                        enableCodeCheck: coderPluginNames.includes("code-check"),
+                        enableReminder: coderPluginNames.includes("reminder"),
+                    });
+                    // 初始化插件（启动 LSP 预加载等）
+                    await adapter.initialize();
+                    pluginAdapterDispose = () => adapter.dispose();
+                    // 过滤有效的插件名称
+                    const enabledPlugins = coderPluginNames.filter((p) => CODER_HARNESS_PLUGINS.has(p.split(":")[0]));
+                    if (enabledPlugins.length > 0) {
+                        console.log(`已启用插件: ${enabledPlugins.join(", ")}`);
+                        output.success(`✅ 已启用插件: ${enabledPlugins.join(", ")}`);
+                        // 显示 LSP 预加载信息
+                        if (coderPluginNames.includes("lsp") && !quiet) {
+                            output.info(`🔧 LSP 服务预加载中，首次诊断可能需要等待...`);
+                        }
+                    }
+                    // 如果启用了 LSP 插件，预热 LSP 服务器
+                    if (coderPluginNames.includes("lsp")) {
+                        try {
+                            // 加载 LSP 配置
+                            const { createLSPConfigLoader } = await import("@ai-setting/roy-agent-coder-harness");
+                            const configLoader = createLSPConfigLoader();
+                            const lspConfig = configLoader.load();
+                            if (!quiet) {
+                                output.info("正在预热 LSP 服务器...");
+                                if (lspConfig.preload) {
+                                    output.info("📋 使用配置文件中的预加载设置");
+                                }
+                            }
+                            const lspManager = createGlobalLSPManager({
+                                idleTimeout: lspConfig.idleTimeout ?? 300000, // 使用配置中的值
+                                maxConnections: lspConfig.maxConnections ?? 10,
+                                autoDownload: lspConfig.autoInstall ?? false,
+                                preloadLanguages: lspConfig.preloadLanguages, // 使用配置中的预加载语言列表
+                            });
+                            // 注册 shutdown handler 确保进程退出时清理
+                            lspManager.registerShutdownHandler();
+                            // 保存 dispose 函数以便在退出时调用
+                            lspManagerDispose = () => lspManager.dispose();
+                            // 预热所有服务器（异步，不阻塞）
+                            // 如果配置了 preload: true 或者明确启用了 lsp 插件，就预热
+                            if (lspConfig.preload || coderPluginNames.includes("lsp")) {
+                                lspManager.prewarm().then(() => {
+                                    if (!quiet) {
+                                        output.success("✅ LSP 服务器预热完成");
+                                    }
+                                }).catch((err) => {
+                                    if (!quiet) {
+                                        output.warn(`⚠ LSP 预热部分失败: ${err.message}`);
+                                    }
+                                });
+                            }
+                        }
+                        catch (error) {
+                            output.warn(`⚠ LSP 预热失败: ${error}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    output.error(`❌ 加载 coder-harness 插件失败: ${error}`);
+                }
+            }
+            // 创建流式输出服务
+            const streamService = new StreamOutputService({
+                showReasoning: args.reasoning,
+                showToolCalls: args.toolCalls,
+                showToolResults: args.toolResults,
+            });
+            // 设置 context window 配置（如果有 LLM component）
+            if (llmComponent) {
+                const contextConfig = llmComponent.getContextThresholdConfig("minimax");
+                streamService.setContextInfo(contextConfig.contextWindow, contextConfig.contextWindow * contextConfig.thresholdRatio);
+            }
+            // 订阅 LLM 事件和上下文事件进行流式输出
+            const unsubscribe = env.subscribeTo([
+                "llm.start",
+                "llm.text",
+                "llm.reasoning",
+                "llm.tool_call",
+                "llm.completed",
+                "llm.error",
+                "tool.result",
+                "tool.error",
+                "context.threshold_exceeded",
+                "context.compacting",
+                "context.compacted",
+            ], (event) => {
+                // 工具执行事件（使用 log() 绕过 quiet 模式）
+                if (event.type === "llm.tool_call" && args.toolCalls) {
+                    const payload = event.payload;
+                    output.log(`🔧 ${payload.toolCall.name}`);
+                    output.log(`   ${payload.toolCall.arguments}`);
+                    return;
+                }
+                if (event.type === "tool.result" && args.toolResults) {
+                    const payload = event.payload;
+                    const result = payload.result?.output ?? payload.result?.error ?? "无输出";
+                    output.log(`📤 ${payload.name}: ${String(result).substring(0, 200)}`);
+                    return;
+                }
+                if (event.type === "tool.error") {
+                    const payload = event.payload;
+                    output.error(`❌ ${payload.toolName ?? "unknown"}: ${payload.error ?? "unknown error"}`);
+                    return;
+                }
+                // 上下文压缩事件
+                if (event.type === "context.threshold_exceeded" && !quiet) {
+                    const payload = event.payload;
+                    output.warn(`⚙ 上下文阈值 (${payload.totalTokens}/${payload.contextWindow})`);
+                }
+                if (event.type === "context.compacting" && !quiet) {
+                    output.info("⚙ 压缩中...");
+                }
+                if (event.type === "context.compacted" && !quiet) {
+                    const payload = event.payload;
+                    output.success(`✓ 已压缩 (${payload.checkpointId ?? "unknown"})`);
+                }
+                // 其他事件交给 streamService 处理
+                streamService.handleEvent(event);
+            });
+            if (!quiet) {
+                output.info(`执行: ${args.message}`);
+            }
+            // ========================================================================
+            // 使用 OTel tracer 创建根 span
+            // 
+            // 使用统一的 roy-tracer，这样可以继承全局 context
+            // ========================================================================
+            const provider = getTracerProvider();
+            const tracer = provider.getTracer("roy-tracer");
+            const rootSpan = tracer.startSpan("act.execute", {
+                attributes: {
+                    message: args.message.substring(0, 200),
+                    sessionId,
+                },
+            });
+            const traceId = rootSpan.spanContext.traceId;
+            if (!quiet) {
+                output.info(`[Trace] ${traceId}`);
+            }
+            // 设置全局 context
+            provider.setGlobalContext(rootSpan.spanContext);
+            // 创建 Context Handler（用于自动压缩）
+            const contextHandler = new ContextHandlerService(env, sessionComponent, { maxRetries: 1, autoCompact: true });
+            // 构建 context（携带 trace id）
+            const context = {
+                sessionId,
+                metadata: {
+                    originalQuery: args.message,
+                    traceId,
+                },
+            };
+            // 执行查询（带上下文阈值处理）
+            let result;
+            try {
+                result = await contextHandler.handleQueryWithContext(args.message, context);
+                rootSpan.end(result);
+            }
+            catch (error) {
+                rootSpan.setAttribute("error", String(error));
+                rootSpan.end(undefined, error instanceof Error ? error : new Error(String(error)));
+                if (error instanceof ContextError && error.code === ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED) {
+                    output.error(`上下文阈值超出限制: ${error.usage?.totalTokens}/${error.contextWindow}`);
+                    output.info("请手动压缩会话: roy sessions compact " + (sessionId || "<session-id>"));
+                }
+                throw error;
+            }
+            finally {
+                // 清理全局 context
+                provider.setGlobalContext(undefined);
+            }
+            unsubscribe();
+            // 流式输出已完成
+            if (!quiet) {
+                output.success("执行完成");
+            }
+        }
+        catch (error) {
+            output.error(`执行失败: ${error instanceof Error ? error.message : String(error)}`);
+            if (process.env.DEBUG) {
+                console.error(error);
+            }
+            process.exit(1);
+        }
+        finally {
+            // 清理 LSP Manager（关闭所有 LSP 连接和进程）
+            if (lspManagerDispose) {
+                await lspManagerDispose();
+            }
+            // 清理 PluginAdapter
+            if (pluginAdapterDispose) {
+                await pluginAdapterDispose();
+            }
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=act.js.map

package/dist/cli/src/commands/commands-add.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview Commands Add Command
+ *
+ * 添加收藏命令
+ */
+import { CommandModule } from "yargs";
+export interface CommandsAddOptions {
+    name: string;
+    target: string;
+    global: boolean;
+    local: boolean;
+    description: string;
+    tips: string;
+    config?: string;
+}
+export declare const CommandsAddCommand: CommandModule<object, CommandsAddOptions>;
+//# sourceMappingURL=commands-add.d.ts.map