@ai-setting/roy-agent-cli 1.0.0

package/src/commands/sessions/compact.test.ts

@@ -0,0 +1,215 @@
+/**
+ * @fileoverview Compact Command 测试
+ * 
+ * TDD 规范：验证 compact 命令的 hint 自动生成逻辑
+ * 
+ * 测试场景：
+ * 1. 当未指定 --scenario 参数时，自动调用 generateCompactHint
+ * 2. 当指定 --scenario 参数时，直接使用传入的 scenario
+ * 3. 输出正确的 hint 信息
+ */
+
+import { describe, expect, test, jest, beforeEach } from "bun:test";
+import type { CompactResult, SessionCheckpoint } from "@ai-setting/roy-agent-core";
+
+// Mock Session 类型
+interface MockSession {
+  id: string;
+  title: string;
+  createdAt: number;
+  updatedAt: number;
+  messageCount: number;
+  metadata: Record<string, unknown>;
+}
+
+const createMockCheckpoint = (overrides?: Partial<SessionCheckpoint>): SessionCheckpoint => ({
+  id: "cp_123",
+  messageIndex: 0,
+  title: "Test Checkpoint",
+  summary: "Test summary",
+  processKeyPoints: ["Point 1", "Point 2"],
+  currentState: "Current state",
+  nextSteps: ["Next step 1"],
+  userIntents: [],
+  messageCountBefore: 10,
+  createdAt: Date.now(),
+  type: "compact",
+  ...overrides,
+});
+
+const createMockCompactResult = (overrides?: Partial<CompactResult>): CompactResult => ({
+  checkpoint: createMockCheckpoint(),
+  deletedMessageCount: 10,
+  remainingMessageCount: 2,
+  checkpointCount: 1,
+  ...overrides,
+});
+
+// 直接从 summary-agent 导入函数进行测试
+import { parseCompactHintResponse } from "../../../../core/src/env/agent/summary-agent";
+
+describe("CompactCommand hint 处理逻辑", () => {
+  
+  describe("两阶段 hint 生成逻辑", () => {
+    
+    test("未指定 scenario 时应调用 generateCompactHint", async () => {
+      // Arrange: 模拟 mock
+      const mockGenerateCompactHint = jest.fn<() => Promise<string>>()
+        .mockResolvedValue("Feature development. User is implementing auth module. Focus on: auth flow decisions.");
+      
+      // Simulate the two-phase logic
+      let scenarioHint = ""; // a.scenario is undefined
+      
+      if (!scenarioHint) {
+        // 模拟 CLI 两阶段逻辑
+        scenarioHint = await mockGenerateCompactHint();
+      }
+      
+      // Assert: generateCompactHint should be called
+      expect(mockGenerateCompactHint).toHaveBeenCalled();
+      expect(scenarioHint).toBe("Feature development. User is implementing auth module. Focus on: auth flow decisions.");
+    });
+    
+    test("指定 scenario 时不应调用 generateCompactHint", async () => {
+      // Arrange: 模拟 mock
+      const mockGenerateCompactHint = jest.fn<() => Promise<string>>()
+        .mockResolvedValue("Should not be called");
+      
+      // Simulate the two-phase logic with provided scenario
+      const providedScenario = "Bug investigation. User is fixing login bug.";
+      let scenarioHint = providedScenario; // a.scenario is provided
+      
+      if (!scenarioHint) {
+        scenarioHint = await mockGenerateCompactHint();
+      }
+      
+      // Assert: generateCompactHint should NOT be called
+      expect(mockGenerateCompactHint).not.toHaveBeenCalled();
+      expect(scenarioHint).toBe(providedScenario);
+    });
+    
+    test("generateCompactHint 失败时应继续执行", async () => {
+      // Arrange: 模拟会失败的 mock
+      const mockGenerateCompactHint = jest.fn<() => Promise<string>>()
+        .mockRejectedValue(new Error("LLM failed"));
+      
+      // Simulate the two-phase logic with fallback
+      let scenarioHint = ""; // a.scenario is undefined
+      
+      if (!scenarioHint) {
+        try {
+          scenarioHint = await mockGenerateCompactHint();
+        } catch (hintError) {
+          // 失败时继续使用空提示
+          scenarioHint = "";
+        }
+      }
+      
+      // Assert: should continue with empty hint
+      expect(mockGenerateCompactHint).toHaveBeenCalled();
+      expect(scenarioHint).toBe("");
+    });
+    
+  });
+  
+  describe("compact 调用参数验证", () => {
+    
+    test("应将生成的 scenarioHint 传递给 compact", async () => {
+      // Arrange
+      const generatedHint = "Feature development. User is implementing auth module.";
+      const mockCompact = jest.fn<() => Promise<CompactResult>>().mockResolvedValue(
+        createMockCompactResult()
+      );
+      
+      // Act: 模拟 compact 调用
+      await mockCompact("session_1", {
+        scenarioHint: generatedHint,
+      });
+      
+      // Assert
+      expect(mockCompact).toHaveBeenCalledWith("session_1", {
+        scenarioHint: generatedHint,
+      });
+    });
+    
+    test("当 scenarioHint 为空时也应传递空字符串", async () => {
+      // Arrange
+      const mockCompact = jest.fn<() => Promise<CompactResult>>().mockResolvedValue(
+        createMockCompactResult()
+      );
+      
+      // Act: 模拟 compact 调用（无 scenario）
+      await mockCompact("session_1", {
+        scenarioHint: "",
+      });
+      
+      // Assert
+      expect(mockCompact).toHaveBeenCalledWith("session_1", {
+        scenarioHint: "",
+      });
+    });
+    
+  });
+  
+  describe("parseCompactHintResponse 行为验证", () => {
+    
+    test("应直接返回 LLM 输出", () => {
+      const llmOutput = "Feature development. User is implementing auth module. Focus on: auth flow decisions.";
+      const result = parseCompactHintResponse(llmOutput);
+      
+      expect(result).toBe(llmOutput);
+    });
+    
+    test("应处理空内容", () => {
+      const result = parseCompactHintResponse("");
+      expect(result).toBe("[Hint extraction failed]");
+    });
+    
+    test("应限制长度", () => {
+      const longText = "a".repeat(600);
+      const result = parseCompactHintResponse(longText);
+      
+      expect(result.length).toBe(503); // 500 + "..."
+      expect(result.endsWith("...")).toBe(true);
+    });
+    
+    test("应处理带首尾空白的输入", () => {
+      const input = "  Feature development. User is implementing auth module.  ";
+      const result = parseCompactHintResponse(input);
+      
+      expect(result).toBe("Feature development. User is implementing auth module.");
+    });
+    
+  });
+  
+  describe("Hint 输出格式验证", () => {
+    
+    test("Hint 应该包含工作类型关键词", () => {
+      const hints = [
+        "Feature development. User is implementing auth module.",
+        "Bug investigation. User is fixing login bug.",
+        "Refactoring. User is migrating to new architecture.",
+      ];
+      
+      hints.forEach(hint => {
+        const result = parseCompactHintResponse(hint);
+        expect(result).toMatch(/Feature development|Bug investigation|Refactoring/i);
+      });
+    });
+    
+    test("Hint 应该包含 Focus on 关键词", () => {
+      const hints = [
+        "Feature development. Focus on: auth flow decisions.",
+        "Bug investigation. Focus on: root cause analysis.",
+        "Refactoring. Focus on: pattern decisions.",
+      ];
+      
+      hints.forEach(hint => {
+        const result = parseCompactHintResponse(hint);
+        expect(result).toMatch(/Focus on:/i);
+      });
+    });
+    
+  });
+  
+});

package/src/commands/sessions/compact.ts

@@ -0,0 +1,269 @@
+/**
+ * @fileoverview Sessions Compact Command
+ * 
+ * 命令：roy sessions compact <session-id>
+ * 
+ * 压缩会话，生成 checkpoint
+ * 
+ * 特性：
+ * 1. 如果未指定 --scenario 参数，自动调用 generateCompactHint 生成场景化提示
+ * 2. 输出生成的 hint prompt（用于告知用户生成了什么指导）
+ * 3. 输出最终的 checkpoint
+ * 4. 复用自动触发 compact 的两阶段逻辑
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type {
+  SessionComponent,
+  Session,
+  LLMComponent,
+  PromptComponent,
+} from "@ai-setting/roy-agent-core";
+
+interface CompactOptions {
+  sessionId: string;
+  summary?: string;
+  scenario?: string;
+  processKeyPoints?: string;
+  currentState?: string;
+  nextSteps?: string;
+  dryRun?: boolean;
+  json?: boolean;
+  config?: string;
+}
+
+export const CompactCommand: CommandModule<object, object> = {
+  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 as any;
+    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") as SessionComponent | undefined;
+
+      if (!sessionComponent) {
+        output.error("SessionComponent not available");
+        process.exit(1);
+      }
+
+      // 检查会话是否存在
+      const session: Session | undefined = await sessionComponent.get(a.sessionId);
+      if (!session) {
+        output.error(`Session not found: ${a.sessionId}`);
+        process.exit(1);
+      }
+
+      // 初始化 SummaryAgent 所需的组件
+      const llmComponent = env.getComponent("llm") as LLMComponent | undefined;
+      const promptComponent = env.getComponent("prompt") as PromptComponent | undefined;
+      
+      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: string) => s.trim()).filter(Boolean);
+      const nextSteps = a.nextSteps?.split(",").map((s: string) => 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: string, i: number) => {
+            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: string, i: number) => {
+          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: string, i: number) => {
+            output.log(`│ ${i + 1}. ${s}`);
+          });
+        }
+        if (result.checkpoint.userIntents?.length) {
+          output.log("├─ User Intents ─────────────────────────────────────┤");
+          result.checkpoint.userIntents.forEach((intent: string, i: number) => {
+            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();
+    }
+  },
+};