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

package/dist/cli/src/commands/shared/query-executor.js

@@ -0,0 +1,254 @@
+/**
+ * @fileoverview Query Executor - 查询执行共享逻辑
+ *
+ * 从 act.ts 抽取的查询执行逻辑，供 interactive 复用
+ *
+ * 功能：
+ * - 初始化 SummaryAgent
+ * - 订阅 LLM/上下文事件
+ * - 流式输出
+ * - ContextHandler 执行
+ * - 支持 abort 流式输出
+ */
+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";
+/**
+ * QueryExecutor - 查询执行器
+ *
+ * 封装查询执行的完整流程
+ */
+export class QueryExecutor {
+    env;
+    sessionComponent;
+    output;
+    quiet;
+    streamService = null;
+    unsubscribe = null;
+    streamOptions = {
+        showReasoning: false,
+        showToolCalls: false,
+        showToolResults: false,
+    };
+    _pendingContextConfig = null;
+    constructor(options) {
+        this.env = options.env;
+        this.sessionComponent = options.sessionComponent;
+        this.output = options.output;
+        this.quiet = options.quiet;
+    }
+    /**
+     * 初始化 SummaryAgent（用于 compact）
+     */
+    initSummaryAgent(llmComponent, promptComponent) {
+        this.sessionComponent.setSummaryComponents(promptComponent, llmComponent);
+    }
+    /**
+     * 初始化流式输出配置（设置 context window 信息）
+     */
+    initStreamOutput(llmComponent, providerId = "minimax") {
+        if (llmComponent) {
+            const contextConfig = llmComponent.getContextThresholdConfig(providerId);
+            // 延迟设置：在 subscribeToEvents 时设置
+            this._pendingContextConfig = contextConfig;
+        }
+    }
+    /**
+     * 订阅事件（用于流式输出）
+     */
+    subscribeToEvents(options) {
+        // 只订阅一次
+        if (this.unsubscribe) {
+            return;
+        }
+        this.streamOptions = options;
+        this.streamService = new StreamOutputService(options);
+        // 设置 context window 信息
+        if (this._pendingContextConfig) {
+            this.streamService.setContextInfo(this._pendingContextConfig.contextWindow, this._pendingContextConfig.contextWindow * this._pendingContextConfig.thresholdRatio);
+            this._pendingContextConfig = null;
+        }
+        this.unsubscribe = this.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) => this.handleEvent(event));
+    }
+    /**
+     * 处理事件
+     */
+    handleEvent(event) {
+        // 工具调用
+        if (event.type === "llm.tool_call" && this.streamOptions.showToolCalls) {
+            const payload = event.payload;
+            this.output.log(`🔧 ${payload.toolCall.name}`);
+            return;
+        }
+        if (event.type === "tool.result" && this.streamOptions.showToolResults) {
+            const payload = event.payload;
+            const result = payload.result?.output ?? payload.result?.error ?? "无输出";
+            this.output.log(`📤 ${payload.name}: ${String(result).substring(0, 200)}`);
+            return;
+        }
+        if (event.type === "tool.error") {
+            this.output.error(`❌ ${event.payload.toolName}: ${event.payload.error}`);
+            return;
+        }
+        // 上下文事件
+        if (event.type === "context.threshold_exceeded" && !this.quiet) {
+            const payload = event.payload;
+            this.output.warn(`⚙ 上下文阈值 (${payload.totalTokens}/${payload.contextWindow})`);
+        }
+        if (event.type === "context.compacting" && !this.quiet) {
+            this.output.info("⚙ 压缩中...");
+        }
+        if (event.type === "context.compacted" && !this.quiet) {
+            this.output.success(`✓ 已压缩 (${event.payload.checkpointId})`);
+        }
+        // 其他事件交给 streamService
+        this.streamService?.handleEvent(event);
+    }
+    /**
+     * 执行查询
+     */
+    async execute(message, sessionId, streamOptions, traceId) {
+        // 合并流式选项
+        const options = {
+            showReasoning: streamOptions?.showReasoning ?? this.streamOptions.showReasoning,
+            showToolCalls: streamOptions?.showToolCalls ?? this.streamOptions.showToolCalls,
+            showToolResults: streamOptions?.showToolResults ?? this.streamOptions.showToolResults,
+        };
+        // 订阅事件（如果尚未订阅）
+        if (!this.unsubscribe) {
+            this.subscribeToEvents(options);
+        }
+        if (!this.quiet) {
+            this.output.info(`执行: ${message}`);
+        }
+        // 创建 Context Handler
+        const contextHandler = new ContextHandlerService(this.env, this.sessionComponent, { maxRetries: 1, autoCompact: true });
+        // 构建 context（携带 trace id）
+        const context = {
+            sessionId,
+            metadata: {
+                originalQuery: message,
+                traceId,
+            },
+        };
+        // ========================================================================
+        // 创建子 span
+        // 
+        // 使用与 interactive.ts 相同的 tracer 实例（roy-tracer）
+        // 这样可以继承 currentContext 中的 traceId
+        // ========================================================================
+        let span;
+        const tracer = getTracerProvider().getTracer("roy-tracer");
+        // 获取当前 tracer 的上下文（应该已经包含根 span 的上下文）
+        const currentContext = tracer.getCurrentContext();
+        span = tracer.startSpan("query-executor.execute", {
+            parent: currentContext,
+            attributes: {
+                query: message.substring(0, 200),
+                sessionId,
+            },
+        });
+        // 执行查询
+        let result;
+        try {
+            result = await contextHandler.handleQueryWithContext(message, context);
+            // 结束 span（成功）
+            if (span) {
+                span.end(result);
+            }
+        }
+        catch (error) {
+            // 结束 span（失败）
+            if (span) {
+                span.setAttribute("error", String(error));
+                span.end(undefined, error instanceof Error ? error : new Error(String(error)));
+            }
+            if (error instanceof ContextError && error.code === ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED) {
+                this.output.error(`上下文阈值超出限制: ${error.usage?.totalTokens}/${error.contextWindow}`);
+                this.output.info("请手动压缩会话: roy sessions compact " + sessionId);
+            }
+            throw error;
+        }
+        finally {
+            // span 结束由 tracer 自动处理
+        }
+        if (!this.quiet) {
+            this.output.success("执行完成");
+        }
+        return result;
+    }
+    /**
+     * 清理资源
+     */
+    dispose() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+    }
+    /**
+     * 获取流式输出服务的完整文本
+     */
+    getFullText() {
+        return this.streamService?.getFullText() ?? "";
+    }
+    /**
+     * 手动压缩会话上下文
+     *
+     * 复用 ContextHandlerService.compactSession 逻辑
+     */
+    async compact(sessionId) {
+        try {
+            // 发布压缩开始事件
+            const envCore = this.env.getComponent("core");
+            if (envCore?.pushEnvEvent) {
+                envCore.pushEnvEvent({
+                    type: "context.compacting",
+                    metadata: { sessionId },
+                    payload: {},
+                });
+            }
+            // 执行 compact
+            const result = await this.sessionComponent.compact(sessionId, {
+                summary: "Manual compact from interactive mode",
+            });
+            // 发布压缩完成事件
+            if (envCore?.pushEnvEvent) {
+                envCore.pushEnvEvent({
+                    type: "context.compacted",
+                    metadata: { sessionId },
+                    payload: {
+                        checkpointId: result.checkpoint.id,
+                        messagesCompacted: result.deletedMessageCount,
+                    },
+                });
+            }
+            return {
+                success: true,
+                checkpoint: result.checkpoint,
+                deletedMessageCount: result.deletedMessageCount,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.output.error(`压缩失败: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+}
+//# sourceMappingURL=query-executor.js.map

package/dist/cli/src/commands/shared/session-manager.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Session Manager - Session 管理共享逻辑
+ *
+ * 从 act.ts 抽取，供 interactive 复用
+ *
+ * 功能：
+ * - 获取/创建 Session
+ * - 设置活跃会话
+ * - 切换会话
+ */
+import { OutputService } from "../../services/output.service";
+import type { Session, SessionComponent } from "@ai-setting/roy-agent-core";
+export interface SessionInitResult {
+    sessionId: string;
+    isNewSession: boolean;
+    sessionTitle: string;
+}
+export interface SessionManagerOptions {
+    sessionComponent: SessionComponent;
+    output: OutputService;
+    quiet: boolean;
+}
+/**
+ * SessionManager - 会话管理
+ */
+export declare class SessionManager {
+    private sessionComponent;
+    private output;
+    private quiet;
+    constructor(options: SessionManagerOptions);
+    /**
+     * 初始化会话
+     *
+     * 优先级：
+     * 1. 指定 sessionId -> 验证并使用
+     * 2. --continue -> 获取上次会话
+     * 3. 无 -> 创建新会话
+     */
+    init(sessionId?: string, isContinue?: boolean): Promise<SessionInitResult>;
+    /**
+     * 切换会话
+     */
+    switchSession(sessionId: string): Promise<SessionInitResult>;
+    /**
+     * 获取当前会话信息
+     */
+    getCurrentSession(): Promise<Session | undefined>;
+}
+//# sourceMappingURL=session-manager.d.ts.map

package/dist/cli/src/commands/shared/session-manager.js

@@ -0,0 +1,93 @@
+/**
+ * @fileoverview Session Manager - Session 管理共享逻辑
+ *
+ * 从 act.ts 抽取，供 interactive 复用
+ *
+ * 功能：
+ * - 获取/创建 Session
+ * - 设置活跃会话
+ * - 切换会话
+ */
+/**
+ * SessionManager - 会话管理
+ */
+export class SessionManager {
+    sessionComponent;
+    output;
+    quiet;
+    constructor(options) {
+        this.sessionComponent = options.sessionComponent;
+        this.output = options.output;
+        this.quiet = options.quiet;
+    }
+    /**
+     * 初始化会话
+     *
+     * 优先级：
+     * 1. 指定 sessionId -> 验证并使用
+     * 2. --continue -> 获取上次会话
+     * 3. 无 -> 创建新会话
+     */
+    async init(sessionId, isContinue) {
+        let targetSessionId = sessionId;
+        let isNewSession = false;
+        // --continue 模式
+        if (isContinue && !targetSessionId) {
+            const activeSession = await this.sessionComponent.getActiveSession();
+            if (activeSession) {
+                targetSessionId = activeSession.id;
+                if (!this.quiet) {
+                    this.output.info(`继续会话: ${activeSession.title} (${targetSessionId})`);
+                }
+            }
+            else {
+                this.output.warn("没有找到上次会话，将创建新会话");
+            }
+        }
+        // 指定 session 验证
+        if (targetSessionId) {
+            await this.sessionComponent.setActiveSession(targetSessionId);
+            const session = await this.sessionComponent.get(targetSessionId);
+            if (session) {
+                if (!this.quiet) {
+                    this.output.info(`会话: ${session.title} (${targetSessionId})`);
+                }
+            }
+            else {
+                this.output.warn(`会话不存在: ${targetSessionId}，将创建新会话`);
+                targetSessionId = undefined;
+            }
+        }
+        // 创建新会话
+        if (!targetSessionId) {
+            const newSession = await this.sessionComponent.create({
+                title: `Session - ${new Date().toLocaleString("zh-CN")}`,
+            });
+            targetSessionId = newSession.id;
+            isNewSession = true;
+            await this.sessionComponent.setActiveSession(targetSessionId);
+            if (!this.quiet) {
+                this.output.info(`创建新会话: ${newSession.title} (${targetSessionId})`);
+            }
+        }
+        const session = await this.sessionComponent.get(targetSessionId);
+        return {
+            sessionId: targetSessionId,
+            isNewSession,
+            sessionTitle: session?.title || "Unknown",
+        };
+    }
+    /**
+     * 切换会话
+     */
+    async switchSession(sessionId) {
+        return this.init(sessionId, false);
+    }
+    /**
+     * 获取当前会话信息
+     */
+    async getCurrentSession() {
+        return this.sessionComponent.getActiveSession();
+    }
+}
+//# sourceMappingURL=session-manager.js.map

package/dist/cli/src/commands/skills/get.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Skills Get Command
+ *
+ * 命令：roy skills get <name>
+ */
+import { CommandModule } from "yargs";
+interface GetOptions {
+    name: string;
+    json?: boolean;
+    config?: string;
+}
+export declare const GetCommand: CommandModule<object, GetOptions>;
+export {};
+//# sourceMappingURL=get.d.ts.map

package/dist/cli/src/commands/skills/get.js

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview Skills Get Command
+ *
+ * 命令：roy skills get <name>
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const GetCommand = {
+    command: "get <name>",
+    describe: "获取指定技能内容",
+    builder: (yargs) => yargs
+        .positional("name", {
+        type: "string",
+        demandOption: true,
+        description: "技能名称",
+    })
+        .option("json", {
+        alias: "j",
+        type: "boolean",
+        default: false,
+        description: "JSON 输出",
+    }),
+    async handler(args) {
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: args.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const skillComponent = env.getComponent("skill");
+            if (!skillComponent) {
+                output.error("SkillComponent not available");
+                process.exit(1);
+            }
+            const skill = skillComponent.getSkill(args.name);
+            if (!skill) {
+                output.error(`Skill not found: ${args.name}`);
+                output.log("Use 'roy skills list' to see available skills.");
+                process.exit(1);
+            }
+            if (args.json) {
+                output.json({
+                    name: skill.name,
+                    description: skill.description,
+                    source: skill.source,
+                    filePath: skill.filePath,
+                    content: skill.content,
+                });
+            }
+            else {
+                // 输出技能信息头
+                output.log(chalk.bold.cyan(`# ${skill.name}`));
+                output.log("");
+                output.log(`${chalk.gray("Description:")} ${skill.description}`);
+                output.log(`${chalk.gray("Source:")} ${skill.source}`);
+                output.log(`${chalk.gray("File:")} ${skill.filePath}`);
+                output.log("");
+                output.log(chalk.bold("--- Content ---"));
+                output.log("");
+                output.log(skill.content);
+            }
+        }
+        catch (error) {
+            output.error(`Failed to get skill: ${error}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=get.js.map

package/dist/cli/src/commands/skills/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Skills Command Entry
+ *
+ * 命令入口：roy skills [action]
+ */
+import { CommandModule } from "yargs";
+/**
+ * Skills Command
+ *
+ * 技能管理命令，提供以下子命令：
+ * - list: 列出所有技能
+ * - get: 获取指定技能内容
+ * - search: 搜索技能
+ * - reload: 重新加载技能
+ * - show-config: 显示配置信息
+ */
+export declare const SkillsCommand: CommandModule;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/src/commands/skills/index.js

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview Skills Command Entry
+ *
+ * 命令入口：roy skills [action]
+ */
+import { ListCommand } from "./list.js";
+import { GetCommand } from "./get.js";
+import { SearchCommand } from "./search.js";
+import { ReloadCommand } from "./reload.js";
+import { ShowConfigCommand } from "./show-config.js";
+/**
+ * Skills Command
+ *
+ * 技能管理命令，提供以下子命令：
+ * - list: 列出所有技能
+ * - get: 获取指定技能内容
+ * - search: 搜索技能
+ * - reload: 重新加载技能
+ * - show-config: 显示配置信息
+ */
+export const SkillsCommand = {
+    command: "skills",
+    describe: "技能管理 - 列出、获取、搜索、重新加载技能",
+    builder: (yargs) => yargs
+        .command(ListCommand)
+        .command(GetCommand)
+        .command(SearchCommand)
+        .command(ReloadCommand)
+        .command(ShowConfigCommand)
+        .demandCommand()
+        .help(),
+    handler: () => {
+        console.log("Use 'roy skills --help' for usage information");
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/skills/list.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Skills List Command
+ *
+ * 命令：roy skills list
+ */
+import { CommandModule } from "yargs";
+export declare const ListCommand: CommandModule<object, object>;
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/src/commands/skills/list.js

@@ -0,0 +1,112 @@
+/**
+ * @fileoverview Skills List Command
+ *
+ * 命令：roy skills list
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const ListCommand = {
+    command: "list",
+    aliases: ["ls"],
+    describe: "列出所有可用技能",
+    builder: (yargs) => yargs
+        .option("source", {
+        alias: "s",
+        type: "string",
+        choices: ["built-in", "user", "project", "all"],
+        default: "all",
+        description: "按来源筛选",
+    })
+        .option("json", {
+        alias: "j",
+        type: "boolean",
+        default: false,
+        description: "JSON 输出",
+    })
+        .option("quiet", {
+        alias: "q",
+        type: "boolean",
+        default: false,
+        description: "简洁输出",
+    }),
+    async handler(args) {
+        const a = args;
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: a.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const skillComponent = env.getComponent("skill");
+            if (!skillComponent) {
+                output.error("SkillComponent not available");
+                process.exit(1);
+            }
+            const skills = skillComponent.getSkillList();
+            // 按来源筛选
+            const filtered = a.source && a.source !== "all"
+                ? skills.filter((s) => s.source === a.source)
+                : skills;
+            if (a.json) {
+                output.json({
+                    skills: filtered.map((s) => ({
+                        name: s.name,
+                        description: s.description,
+                        source: s.source,
+                    })),
+                    count: filtered.length,
+                });
+            }
+            else if (a.quiet) {
+                filtered.forEach((s) => output.log(s.name));
+            }
+            else {
+                // 表格输出
+                const header = [
+                    chalk.bold("Name"),
+                    chalk.bold("Description"),
+                    chalk.bold("Source"),
+                ].join(" | ");
+                const sourceColor = (source) => {
+                    switch (source) {
+                        case "project": return chalk.green;
+                        case "user": return chalk.blue;
+                        case "built-in": return chalk.gray;
+                        default: return chalk.white;
+                    }
+                };
+                const rows = filtered.map((s) => {
+                    const desc = s.description.length > 50
+                        ? s.description.slice(0, 47) + "..."
+                        : s.description;
+                    return [
+                        chalk.cyan(s.name),
+                        desc,
+                        sourceColor(s.source)(`[${s.source}]`),
+                    ].join(" | ");
+                });
+                output.log([
+                    `┌─ Skills ${"─".repeat(55)}┐`,
+                    `│${header}│`,
+                    "├" + "─".repeat(header.length + 2) + "┤",
+                    ...rows.map(r => `│${r}│`),
+                    "└" + "─".repeat(header.length + 2) + "┘",
+                    "",
+                    chalk.gray(`Total: ${filtered.length} skills`),
+                ].join("\n"));
+            }
+        }
+        catch (error) {
+            output.error(`Failed to list skills: ${error}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=list.js.map

package/dist/cli/src/commands/skills/reload.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Skills Reload Command
+ *
+ * 命令：roy skills reload
+ */
+import { CommandModule } from "yargs";
+interface ReloadOptions {
+    config?: string;
+}
+export declare const ReloadCommand: CommandModule<object, ReloadOptions>;
+export {};
+//# sourceMappingURL=reload.d.ts.map