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

package/dist/cli/src/commands/sessions/compact.js

@@ -0,0 +1,240 @@
+/**
+ * @fileoverview Sessions Compact Command
+ *
+ * 命令：roy sessions compact <session-id>
+ *
+ * 压缩会话，生成 checkpoint
+ *
+ * 特性：
+ * 1. 如果未指定 --scenario 参数，自动调用 generateCompactHint 生成场景化提示
+ * 2. 输出生成的 hint prompt（用于告知用户生成了什么指导）
+ * 3. 输出最终的 checkpoint
+ * 4. 复用自动触发 compact 的两阶段逻辑
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const CompactCommand = {
+    command: "compact <session-id>",
+    aliases: ["compress", "checkpoint"],
+    describe: "压缩会话，生成 checkpoint [new]",
+    builder: (yargs) => yargs
+        .positional("session-id", {
+        describe: "会话 ID",
+        type: "string",
+        demandOption: true,
+    })
+        .option("summary", { alias: "s", type: "string", description: "摘要提示" })
+        .option("scenario", {
+        alias: "S",
+        type: "string",
+        description: "场景提示（可选）。不指定时自动生成。例如：'Task execution in progress: implementing feature X, current working directory is /path/to/project'"
+    })
+        .option("process-key-points", { type: "string", description: "过程要点（逗号分隔）" })
+        .option("current-state", { type: "string", description: "当前状态" })
+        .option("next-steps", { type: "string", description: "后续待跟进（逗号分隔）" })
+        .option("dry-run", { alias: "d", type: "boolean", default: false, description: "预览压缩效果" })
+        .option("json", { alias: "j", type: "boolean", default: false }),
+    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 sessionComponent = env.getComponent("session");
+            if (!sessionComponent) {
+                output.error("SessionComponent not available");
+                process.exit(1);
+            }
+            // 检查会话是否存在
+            const session = await sessionComponent.get(a.sessionId);
+            if (!session) {
+                output.error(`Session not found: ${a.sessionId}`);
+                process.exit(1);
+            }
+            // 初始化 SummaryAgent 所需的组件
+            const llmComponent = env.getComponent("llm");
+            const promptComponent = env.getComponent("prompt");
+            if (llmComponent && promptComponent) {
+                sessionComponent.setSummaryComponents(promptComponent, llmComponent);
+            }
+            else {
+                output.error("LLMComponent or PromptComponent not available. Cannot generate checkpoint.");
+                process.exit(1);
+            }
+            // Dry run - 预览
+            if (a.dryRun) {
+                const preview = await sessionComponent.previewCompact(a.sessionId);
+                if (a.json) {
+                    output.json({
+                        sessionId: a.sessionId,
+                        preview: {
+                            messageCountToCompact: preview.messageCountToCompact,
+                            estimatedCheckpointTokens: preview.estimatedCheckpointTokens,
+                            wouldTrigger: preview.wouldTrigger,
+                        },
+                        dryRun: true,
+                    });
+                }
+                else {
+                    output.log(chalk.bold("┌─ Compact Preview ─────────────────────────────────┐"));
+                    output.log(`│ Session: ${session.title}`);
+                    output.log(`│ Messages to compact: ${chalk.yellow(preview.messageCountToCompact)}`);
+                    output.log(`│ Estimated checkpoint tokens: ${preview.estimatedCheckpointTokens}`);
+                    output.log(`│ Would trigger: ${preview.wouldTrigger ? chalk.green("Yes") : chalk.gray("No")}`);
+                    output.log("│");
+                    output.log("│ " + chalk.gray("(Dry run - no changes made)"));
+                    output.log("└" + "─".repeat(51) + "┘");
+                }
+                return;
+            }
+            // 解析逗号分隔的选项
+            const processKeyPoints = a.processKeyPoints?.split(",").map((s) => s.trim()).filter(Boolean);
+            const nextSteps = a.nextSteps?.split(",").map((s) => s.trim()).filter(Boolean);
+            // ================================================================
+            // 两阶段逻辑：如果未指定 scenario，自动生成 hint
+            // ================================================================
+            let scenarioHint = a.scenario || "";
+            if (!scenarioHint) {
+                if (!a.json) {
+                    output.info("Generating scenario hint...");
+                }
+                try {
+                    scenarioHint = await sessionComponent.generateCompactHint(a.sessionId);
+                    if (!a.json) {
+                        output.log(chalk.bold("├─ Auto-generated Scenario Hint ──────────────────────────┤"));
+                        output.log("│ " + chalk.cyan(scenarioHint.substring(0, 70)));
+                        if (scenarioHint.length > 70) {
+                            output.log(chalk.gray("│ ") + scenarioHint.substring(70, 140));
+                        }
+                    }
+                }
+                catch (hintError) {
+                    if (!a.json) {
+                        output.warn("Failed to generate scenario hint, continuing with empty hint");
+                    }
+                    scenarioHint = "";
+                }
+            }
+            else {
+                if (!a.json) {
+                    output.info(`Using provided scenario: ${a.scenario}`);
+                }
+            }
+            // ================================================================
+            // 执行 compact
+            // ================================================================
+            if (!a.json) {
+                output.info("Generating checkpoint...");
+            }
+            const result = await sessionComponent.compact(a.sessionId, {
+                summary: a.summary,
+                scenarioHint,
+                processKeyPoints,
+                currentState: a.currentState,
+                nextSteps,
+            });
+            if (a.json) {
+                output.json({
+                    success: true,
+                    hint: {
+                        autoGenerated: !a.scenario,
+                        value: scenarioHint || null,
+                    },
+                    checkpoint: {
+                        id: result.checkpoint.id,
+                        title: result.checkpoint.title,
+                        processKeyPoints: result.checkpoint.processKeyPoints,
+                        currentState: result.checkpoint.currentState,
+                        nextSteps: result.checkpoint.nextSteps,
+                        userIntents: result.checkpoint.userIntents,
+                        createdAt: new Date(result.checkpoint.createdAt).toISOString(),
+                    },
+                    stats: {
+                        messagesCompacted: result.deletedMessageCount,
+                        remainingMessages: result.remainingMessageCount,
+                        totalCheckpoints: result.checkpointCount,
+                    },
+                });
+            }
+            else {
+                // 成功输出
+                output.log(chalk.bold.green("┌─ Checkpoint Created ────────────────────────────────┐"));
+                output.log(`│ ID:      ${result.checkpoint.id}`);
+                output.log(`│ Title:   ${result.checkpoint.title}`);
+                output.log(`│ Type:    compact`);
+                output.log(`│ Created: ${new Date(result.checkpoint.createdAt).toLocaleString("zh-CN")}`);
+                // Scenario Hint 部分
+                output.log(chalk.bold("├─ Scenario Hint ────────────────────────────────────┤"));
+                if (scenarioHint) {
+                    const hintLines = scenarioHint.split("\n");
+                    hintLines.forEach((line, i) => {
+                        if (i === 0) {
+                            output.log(chalk.cyan("│ " + line.substring(0, 48)));
+                            if (line.length > 48) {
+                                for (let j = 48; j < line.length; j += 48) {
+                                    output.log(chalk.gray("│ ") + line.substring(j, j + 48));
+                                }
+                            }
+                        }
+                        else {
+                            output.log(chalk.gray("│ ") + line);
+                        }
+                    });
+                }
+                else {
+                    output.log(chalk.gray("│ (no hint)"));
+                }
+                output.log("├─ Process Key Points ─────────────────────────────────┤");
+                result.checkpoint.processKeyPoints.forEach((p, i) => {
+                    output.log(`│ ${i + 1}. ${p}`);
+                });
+                output.log("├─ Current State ─────────────────────────────────────┤");
+                output.log("│ " + result.checkpoint.currentState);
+                if (result.checkpoint.nextSteps?.length) {
+                    output.log("├─ Next Steps ───────────────────────────────────────┤");
+                    result.checkpoint.nextSteps.forEach((s, i) => {
+                        output.log(`│ ${i + 1}. ${s}`);
+                    });
+                }
+                if (result.checkpoint.userIntents?.length) {
+                    output.log("├─ User Intents ─────────────────────────────────────┤");
+                    result.checkpoint.userIntents.forEach((intent, i) => {
+                        output.log(`│ ${i + 1}. ${intent}`);
+                    });
+                }
+                if (result.checkpoint.recentMessages?.length) {
+                    output.log("├─ Recent Messages (preserved for context) ──────────┤");
+                    result.checkpoint.recentMessages.forEach((msg) => {
+                        const prefix = msg.role === 'user' ? '👤' : '🤖';
+                        const content = msg.content.length > 60
+                            ? msg.content.substring(0, 60) + '...'
+                            : msg.content;
+                        output.log(chalk.gray(`│ ${prefix} [${msg.role}] ${content}`));
+                    });
+                }
+                output.log("├─ Stats ─────────────────────────────────────────────┤");
+                output.log(`│ Messages compacted: ${chalk.yellow(result.deletedMessageCount)}`);
+                output.log(`│ Remaining messages: ${result.remainingMessageCount}`);
+                output.log(`│ Total checkpoints: ${result.checkpointCount}`);
+                output.log("└" + "─".repeat(51) + "┘");
+            }
+        }
+        catch (error) {
+            output.error(`Failed to compact session: ${error instanceof Error ? error.message : String(error)}`);
+            if (process.env.DEBUG) {
+                console.error(error);
+            }
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=compact.js.map

package/dist/cli/src/commands/sessions/delete.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Sessions Delete Command
+ *
+ * 命令：roy sessions delete <session-id...>
+ *
+ * 支持：
+ * - 单个删除：roy sessions delete <session-id>
+ * - 批量删除：roy sessions delete <session-id-1> <session-id-2> ...
+ * - 全量删除：roy sessions delete --all
+ * - 按时间删除：roy sessions delete --older-than <days>
+ */
+import { CommandModule } from "yargs";
+export declare const DeleteCommand: CommandModule<object, object>;
+//# sourceMappingURL=delete.d.ts.map

package/dist/cli/src/commands/sessions/delete.js

@@ -0,0 +1,214 @@
+/**
+ * @fileoverview Sessions Delete Command
+ *
+ * 命令：roy sessions delete <session-id...>
+ *
+ * 支持：
+ * - 单个删除：roy sessions delete <session-id>
+ * - 批量删除：roy sessions delete <session-id-1> <session-id-2> ...
+ * - 全量删除：roy sessions delete --all
+ * - 按时间删除：roy sessions delete --older-than <days>
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const DeleteCommand = {
+    command: "delete [session-ids...]",
+    aliases: ["rm"],
+    describe: "删除会话（支持批量删除和全量删除）",
+    builder: (yargs) => yargs
+        .positional("session-ids", {
+        describe: "会话 ID（可指定多个）",
+        type: "string",
+        demandOption: false,
+    })
+        .option("all", {
+        alias: "a",
+        type: "boolean",
+        default: false,
+        description: "删除所有会话",
+    })
+        .option("older-than", {
+        alias: "o",
+        type: "number",
+        description: "删除指定天数之前的会话",
+    })
+        .option("keep-active", {
+        alias: "k",
+        type: "boolean",
+        default: false,
+        description: "全量删除时保留当前活动会话",
+    })
+        .option("force", {
+        alias: "f",
+        type: "boolean",
+        default: false,
+        description: "跳过确认直接删除",
+    })
+        .option("dry-run", {
+        alias: "d",
+        type: "boolean",
+        default: false,
+        description: "预览模式，只显示将要删除的会话",
+    })
+        .check((argv) => {
+        // 确保至少指定了一种删除方式
+        const sessionIds = argv.sessionIds;
+        const hasIds = sessionIds && sessionIds.length > 0;
+        const hasAll = argv.all === true;
+        const hasOlderThan = argv.olderThan !== undefined;
+        if (!hasIds && !hasAll && !hasOlderThan) {
+            throw new Error("请指定要删除的会话 ID，或使用 --all 或 --older-than 选项");
+        }
+        return true;
+    }),
+    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 sessionComponent = env.getComponent("session");
+            if (!sessionComponent) {
+                output.error("SessionComponent not available");
+                process.exit(1);
+            }
+            const activeSessionId = sessionComponent.getActiveSessionId();
+            let sessionsToDelete = [];
+            // 确定要删除的会话
+            if (a.sessionIds && a.sessionIds.length > 0) {
+                // 批量删除指定的会话
+                for (const id of a.sessionIds) {
+                    const session = await sessionComponent.get(id);
+                    if (session) {
+                        sessionsToDelete.push(session);
+                    }
+                    else {
+                        output.warn(`Session not found: ${id}`);
+                    }
+                }
+            }
+            else if (a.all) {
+                // 全量删除
+                const allSessions = await sessionComponent.list({ limit: 100000 });
+                sessionsToDelete = allSessions.filter((s) => {
+                    if (a.keepActive && s.id === activeSessionId) {
+                        return false;
+                    }
+                    return true;
+                });
+                if (a.keepActive && sessionsToDelete.length > 0) {
+                    output.log(chalk.yellow(`Keeping active session: ${activeSessionId}`));
+                }
+            }
+            else if (a.olderThan !== undefined) {
+                // 按时间删除
+                const cutoffDate = new Date();
+                cutoffDate.setDate(cutoffDate.getDate() - a.olderThan);
+                const cutoffTimestamp = cutoffDate.getTime();
+                const allSessions = await sessionComponent.list({ limit: 100000 });
+                sessionsToDelete = allSessions.filter((s) => {
+                    const updatedAt = new Date(s.updatedAt).getTime();
+                    if (updatedAt < cutoffTimestamp) {
+                        if (a.keepActive && s.id === activeSessionId) {
+                            return false;
+                        }
+                        return true;
+                    }
+                    return false;
+                });
+                output.log(chalk.gray(`Deleting sessions not updated since ${cutoffDate.toISOString().split("T")[0]} (${a.olderThan} days ago)`));
+            }
+            else {
+                // 这个分支理论上不会到达，因为 yargs check 已经验证了
+                output.log("No sessions to delete");
+                return;
+            }
+            if (sessionsToDelete.length === 0) {
+                output.log("No sessions to delete");
+                return;
+            }
+            // 预览模式
+            if (a.dryRun) {
+                output.log(chalk.yellow(`[DRY RUN] Would delete ${sessionsToDelete.length} session(s):\n`));
+                sessionsToDelete.forEach((s, i) => {
+                    const marker = s.id === activeSessionId ? chalk.green("▶") : " ";
+                    output.log(`  ${marker} ${s.id}`);
+                    output.log(`     Title: ${s.title}`);
+                    output.log(`     Updated: ${new Date(s.updatedAt).toLocaleString()}`);
+                    if (i < sessionsToDelete.length - 1)
+                        output.log("");
+                });
+                return;
+            }
+            // 确认删除
+            if (!a.force) {
+                output.log(chalk.red(`\n⚠️  About to delete ${sessionsToDelete.length} session(s):\n`));
+                sessionsToDelete.forEach((s, i) => {
+                    const marker = s.id === activeSessionId ? chalk.green("▶") : " ";
+                    output.log(`  ${marker} ${s.id} - ${s.title}`);
+                });
+                output.log("");
+                const answer = await new Promise((resolve) => {
+                    const readline = require("readline");
+                    const rl = readline.createInterface({
+                        input: process.stdin,
+                        output: process.stdout,
+                    });
+                    rl.question(chalk.red("Type 'yes' to confirm deletion: "), (res) => {
+                        rl.close();
+                        resolve(res);
+                    });
+                });
+                if (answer.toLowerCase() !== "yes") {
+                    output.log("Deletion cancelled");
+                    return;
+                }
+            }
+            // 执行删除
+            let successCount = 0;
+            let failCount = 0;
+            const errors = [];
+            for (const session of sessionsToDelete) {
+                try {
+                    const success = await sessionComponent.delete(session.id);
+                    if (success) {
+                        successCount++;
+                    }
+                    else {
+                        failCount++;
+                        errors.push(`Failed to delete: ${session.id}`);
+                    }
+                }
+                catch (error) {
+                    failCount++;
+                    errors.push(`${session.id}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            // 输出结果
+            if (successCount > 0) {
+                output.success(chalk.green(`✓`) + ` Deleted ${successCount} session(s)`);
+            }
+            if (failCount > 0) {
+                output.error(`✗ Failed to delete ${failCount} session(s)`);
+                errors.forEach((e) => output.error(`  - ${e}`));
+            }
+            if (successCount === 0 && failCount === 0) {
+                output.log("No sessions were deleted");
+            }
+        }
+        catch (error) {
+            output.error(`Failed to delete session: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=delete.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Sessions Get Command
+ *
+ * 命令：roy sessions get <session-id>
+ */
+import { CommandModule } from "yargs";
+export declare const GetCommand: CommandModule<object, object>;
+//# sourceMappingURL=get.d.ts.map

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

@@ -0,0 +1,129 @@
+/**
+ * @fileoverview Sessions Get Command
+ *
+ * 命令：roy sessions get <session-id>
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const GetCommand = {
+    command: "get <session-id>",
+    aliases: ["show"],
+    describe: "获取会话详情",
+    builder: (yargs) => yargs
+        .positional("session-id", {
+        describe: "会话 ID",
+        type: "string",
+        demandOption: true,
+    })
+        .option("messages", { type: "boolean", default: false })
+        .option("checkpoints", { alias: "c", type: "boolean", default: false })
+        .option("json", { alias: "j", type: "boolean", default: false }),
+    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 sessionComponent = env.getComponent("session");
+            if (!sessionComponent) {
+                output.error("SessionComponent not available");
+                process.exit(1);
+            }
+            const session = await sessionComponent.get(a.sessionId);
+            if (!session) {
+                output.error(`Session not found: ${a.sessionId}`);
+                process.exit(1);
+            }
+            const activeSessionId = sessionComponent.getActiveSessionId();
+            const checkpoints = a.checkpoints
+                ? await sessionComponent.getCheckpoints(a.sessionId)
+                : [];
+            if (a.json) {
+                output.json({
+                    id: session.id,
+                    title: session.title,
+                    directory: session.directory,
+                    parentID: session.parentID,
+                    messageCount: session.messageCount,
+                    isActive: session.id === activeSessionId,
+                    checkpoints: checkpoints.map((cp) => ({
+                        id: cp.id,
+                        title: cp.title,
+                        messageIndex: cp.messageIndex,
+                        type: cp.type,
+                        createdAt: new Date(cp.createdAt).toISOString(),
+                        processKeyPoints: cp.processKeyPoints,
+                        currentState: cp.currentState,
+                    })),
+                    metadata: session.metadata,
+                    createdAt: new Date(session.createdAt).toISOString(),
+                    updatedAt: new Date(session.updatedAt).toISOString(),
+                });
+            }
+            else {
+                // 详细信息输出
+                const lines = [
+                    chalk.bold("┌─ Session Details ─────────────────────────────────┐"),
+                    `│ ID:          ${session.id}`,
+                    `│ Title:       ${session.title}`,
+                    `│ Directory:   ${session.directory}`,
+                    `│ Messages:    ${session.messageCount}`,
+                    `│ Active:      ${session.id === activeSessionId ? chalk.green("✓") : chalk.gray("-")}`,
+                    `│ Created:     ${new Date(session.createdAt).toLocaleString("zh-CN")}`,
+                    `│ Updated:     ${new Date(session.updatedAt).toLocaleString("zh-CN")}`,
+                ];
+                // Check if this is a workflow session
+                const workflowMeta = session.metadata?.type === 'workflow'
+                    ? session.metadata
+                    : null;
+                if (workflowMeta) {
+                    lines.push("├─ Workflow Info ─────────────────────────────────────┤");
+                    lines.push(`│ Type:        ${chalk.cyan("workflow")}`);
+                    lines.push(`│ Workflow:    ${workflowMeta.workflowName}`);
+                    if (workflowMeta.workflowId) {
+                        lines.push(`│ Workflow ID: ${workflowMeta.workflowId}`);
+                    }
+                    const statusColor = workflowMeta.status === 'running' ? chalk.green
+                        : workflowMeta.status === 'paused' ? chalk.yellow
+                            : workflowMeta.status === 'completed' ? chalk.gray
+                                : chalk.red;
+                    lines.push(`│ Status:      ${statusColor(workflowMeta.status)}`);
+                    // Display agent sub-sessions if any
+                    if (workflowMeta.agentSessions && workflowMeta.agentSessions.length > 0) {
+                        lines.push("├─ Agent Sub-sessions ─────────────────────────────────┤");
+                        workflowMeta.agentSessions.forEach((agent) => {
+                            const agentStatusColor = agent.status === 'active' ? chalk.green
+                                : agent.status === 'paused' ? chalk.yellow
+                                    : chalk.gray;
+                            lines.push(`│ ${agent.nodeId}: ${agent.sessionId} (${agentStatusColor(agent.status)})`);
+                        });
+                    }
+                }
+                if (checkpoints.length > 0) {
+                    lines.push("├─ Checkpoints ──────────────────────────────────────┤");
+                    checkpoints.slice(-5).reverse().forEach((cp, i) => {
+                        const marker = i === 0 ? "✓ Latest" : "  #" + (checkpoints.length - i);
+                        lines.push(`│ ${marker}  ${cp.title}`);
+                        lines.push(`│           ${new Date(cp.createdAt).toLocaleString("zh-CN")}`);
+                    });
+                }
+                lines.push("└───────────────────────────────────────────────────┘");
+                output.log(lines.join("\n"));
+            }
+        }
+        catch (error) {
+            output.error(`Failed to get session: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=get.js.map

package/dist/cli/src/commands/sessions/grep.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Sessions Grep Command
+ *
+ * 命令：roy sessions grep <query>
+ *
+ * 在所有会话消息中进行全文搜索，支持：
+ * - 多关键字搜索 (AND/OR/NOT)
+ * - 按会话过滤
+ * - 按时间范围过滤
+ * - 结果以 session 为单位聚合展示
+ * - --quiet 安静模式
+ */
+import { CommandModule } from "yargs";
+export declare const GrepCommand: CommandModule<object, object>;
+//# sourceMappingURL=grep.d.ts.map