@ai-setting/roy-agent-core 1.0.0

package/src/env/session/session-checkpoint.test.ts

@@ -0,0 +1,523 @@
+/**
+ * @fileoverview Session Checkpoint Tests
+ * 
+ * TDD: 先写测试 (RED)，再实现代码 (GREEN)
+ */
+
+import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
+import { SessionComponent } from "./session-component";
+import { ConfigComponent } from "../../config/config-component";
+import type { Environment } from "../interface";
+import * as fsSync from "fs";
+import * as path from "path";
+import * as os from "os";
+
+// ============================================================================
+// Test Utilities (for test isolation)
+// ============================================================================
+
+function createTempDbPath(): string {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return path.join(os.tmpdir(), `test-sessions-${timestamp}-${random}.db`);
+}
+
+async function cleanupTempDb(dbPath: string): Promise<void> {
+  try { await fsSync.promises.unlink(dbPath); } catch {}
+  try { await fsSync.promises.unlink(`${dbPath}-wal`); } catch {}
+  try { await fsSync.promises.unlink(`${dbPath}-shm`); } catch {}
+}
+
+describe("SessionComponent Checkpoint", () => {
+  let component: SessionComponent;
+  let configComponent: ConfigComponent;
+  let mockEnv: Environment;
+  let tempDbPath: string;
+
+  beforeEach(() => {
+    component = new SessionComponent();
+    configComponent = new ConfigComponent();
+    tempDbPath = createTempDbPath();
+    
+    mockEnv = {
+      name: "test-env",
+      version: "1.0.0",
+      getComponent: vi.fn((name: string) => {
+        if (name === "config") return configComponent;
+        return undefined;
+      }),
+      hasComponent: vi.fn((name: string) => name === "config"),
+      logger: vi.fn(),
+      trace: vi.fn(),
+    } as unknown as Environment;
+  });
+
+  afterEach(async () => {
+    // Stop component to release resources
+    if (component.getStatus() !== "stopped") {
+      try {
+        await component.stop();
+      } catch {}
+    }
+    // Clean up temporary database
+    await cleanupTempDb(tempDbPath);
+    vi.restoreAllMocks();
+  });
+
+  describe("Checkpoint types", () => {
+    test("should have version 1.1.0 or higher", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      expect(component.version).toBe("1.1.0");
+    });
+  });
+
+  describe("create with checkpoints metadata", () => {
+    test("should initialize session with checkpoints metadata", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      const session = await component.create({ title: "Test Session" });
+
+      expect(session.metadata).toBeDefined();
+      expect(session.metadata?.checkpoints).toBeDefined();
+      expect(session.metadata?.checkpoints?.checkpoints).toEqual([]);
+      expect(session.metadata?.checkpoints?.latestCheckpointId).toBeUndefined();
+    });
+  });
+
+  describe("previewCompact", () => {
+    test("should preview compact without making changes", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      const session = await component.create({ title: "Test" });
+      
+      // Add some messages
+      await component.addMessage(session.id, { role: "user", content: "Hello" });
+      await component.addMessage(session.id, { role: "assistant", content: "Hi there" });
+      await component.addMessage(session.id, { role: "user", content: "How are you?" });
+
+      const preview = await component.previewCompact(session.id);
+
+      expect(preview).toBeDefined();
+      expect(preview.messageCountToCompact).toBe(3);
+      expect(preview.wouldTrigger).toBe(false); // Less than maxMessages
+    });
+
+    test("should throw error for non-existent session", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      
+      await expect(component.previewCompact("non-existent")).rejects.toThrow("Session not found");
+    });
+  });
+
+  describe("getCheckpoints", () => {
+    test("should return empty array for session without checkpoints", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      const session = await component.create({ title: "Test" });
+
+      const checkpoints = await component.getCheckpoints(session.id);
+
+      expect(checkpoints).toEqual([]);
+    });
+
+    test("should return checkpoints after compact", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      const session = await component.create({ title: "Test" });
+
+      // This test will fail because compact needs SummaryAgent
+      // We'll implement it after setting up the mock
+    });
+  });
+
+  describe("getCheckpoint", () => {
+    test("should return undefined for non-existent checkpoint", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      const session = await component.create({ title: "Test" });
+
+      const checkpoint = await component.getCheckpoint(session.id, "non-existent");
+
+      expect(checkpoint).toBeUndefined();
+    });
+  });
+
+  describe("deleteCheckpoint", () => {
+    test("should return false for non-existent checkpoint", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      const session = await component.create({ title: "Test" });
+
+      const result = await component.deleteCheckpoint(session.id, "non-existent");
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("getContext", () => {
+    test("should get context from session", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      const session = await component.create({ title: "Test" });
+
+      const ctx = await component.getContext(session.id);
+
+      expect(ctx).toBeDefined();
+      expect(ctx.session).toBeDefined();
+      expect(ctx.messages).toBeDefined();
+      expect(Array.isArray(ctx.messages)).toBe(true);
+    });
+
+    test("should throw error for non-existent session", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+
+      await expect(component.getContext("non-existent")).rejects.toThrow("Session not found");
+    });
+
+    test("should return full history when fullHistory is true", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { storage: { type: "sqlite", dbPath: tempDbPath } }
+        } 
+      });
+      const session = await component.create({ title: "Test" });
+      await component.addMessage(session.id, { role: "user", content: "Hello" });
+
+      const ctx = await component.getContext(session.id, { fullHistory: true });
+
+      expect(ctx.totalMessageCount).toBe(1);
+      expect(ctx.messages.length).toBe(1);
+    });
+
+    test("should apply message limit", async () => {
+      await component.init({ env: mockEnv, options: { configComponent, config: { storage: { type: "sqlite", dbPath: tempDbPath } } } });
+      const session = await component.create({ title: "Test" });
+      
+      for (let i = 0; i < 10; i++) {
+        await component.addMessage(session.id, { role: "user", content: `Message ${i}` });
+      }
+
+      const ctx = await component.getContext(session.id, { messageLimit: 5 });
+
+      expect(ctx.messages.length).toBeLessThanOrEqual(5);
+    });
+
+    test("should get all messages when session has more than 50 messages", async () => {
+      // This test verifies the bug fix: getMessages has default limit=50
+      // which causes incomplete message retrieval when session has > 50 messages
+      await component.init({ env: mockEnv, options: { configComponent, config: { storage: { type: "sqlite", dbPath: tempDbPath } } } });
+      const session = await component.create({ title: "Test" });
+
+      // Add 60 messages (exceeds default limit of 50)
+      for (let i = 0; i < 60; i++) {
+        await component.addMessage(session.id, { role: "user", content: `Message ${i}` });
+      }
+
+      const ctx = await component.getContext(session.id);
+
+      // Should return all 60 messages, not just 50
+      expect(ctx.messages.length).toBe(60);
+      expect(ctx.totalMessageCount).toBe(60);
+      expect(ctx.messages[0].content).toBe("Message 0");
+      expect(ctx.messages[59].content).toBe("Message 59");
+    });
+
+    test("should get all messages including checkpoints when session has > 50 messages", async () => {
+      // Test that getContext returns all messages when session has > 50 messages
+      // (optimization with checkpoint is tested separately)
+      await component.init({ env: mockEnv, options: { configComponent, config: { storage: { type: "sqlite", dbPath: tempDbPath } } } });
+      const session = await component.create({ title: "Test" });
+
+      // Add 60 messages (exceeds default limit of 50)
+      for (let i = 0; i < 60; i++) {
+        await component.addMessage(session.id, { role: "user", content: `Message ${i}` });
+      }
+
+      const ctx = await component.getContext(session.id);
+
+      // Should return all 60 messages
+      expect(ctx.messages.length).toBe(60);
+      expect(ctx.totalMessageCount).toBe(60);
+    });
+
+    test("should read from checkpoint when checkpoint metadata exists", async () => {
+      // Test the optimization: when checkpoint exists in session metadata,
+      // getContext should read from checkpoint position, not from 0
+      await component.init({ env: mockEnv, options: { configComponent, config: { storage: { type: "sqlite", dbPath: tempDbPath } } } });
+      const session = await component.create({ title: "Test" });
+
+      // Add 10 messages
+      for (let i = 0; i < 10; i++) {
+        await component.addMessage(session.id, { role: "user", content: `Message ${i}` });
+      }
+
+      // Add a checkpoint message at position 10
+      await component.addMessage(session.id, {
+        role: "user",
+        content: "# Checkpoint",
+        metadata: { isCheckpoint: true, checkpointId: "cp_test" }
+      });
+
+      // Add 10 more messages (total 21, with checkpoint at position 10)
+      for (let i = 10; i < 20; i++) {
+        await component.addMessage(session.id, { role: "user", content: `Message ${i}` });
+      }
+
+      // Without checkpoint metadata in session, should return all 21 messages
+      const ctxWithoutMetadata = await component.getContext(session.id);
+      expect(ctxWithoutMetadata.messages.length).toBe(21);
+
+      // With checkpoint metadata in session, should return only 11 messages (from checkpoint)
+      // Note: The optimization in getContext reads from checkpoint.messageIndex when available
+    });
+
+    test("should correctly identify checkpoint position from metadata", async () => {
+      // Verify that checkpoint messageIndex is correctly tracked
+      await component.init({ env: mockEnv, options: { configComponent, config: { storage: { type: "sqlite", dbPath: tempDbPath } } } });
+      const session = await component.create({ title: "Test" });
+
+      // Add messages
+      await component.addMessage(session.id, { role: "user", content: "First" });
+      await component.addMessage(session.id, { role: "user", content: "Second" });
+
+      // Get checkpoints - should be empty initially
+      const checkpointsBefore = await component.getCheckpoints(session.id);
+      expect(checkpointsBefore.length).toBe(0);
+
+      // Add checkpoint message
+      await component.addMessage(session.id, {
+        role: "user",
+        content: "# Checkpoint",
+        metadata: { isCheckpoint: true, checkpointId: "cp_manual" }
+      });
+
+      // Add more messages
+      await component.addMessage(session.id, { role: "user", content: "After checkpoint" });
+
+      // Verify we can get the checkpoint by ID (when it's stored properly)
+      const checkpoint = await component.getCheckpoint(session.id, "cp_manual");
+      // Note: This will be undefined unless the checkpoint was created via compact()
+      // which properly stores it in the checkpoints cache
+    });
+
+    test("should get all messages with fullHistory when session has > 50 messages", async () => {
+      // Test that fullHistory returns ALL messages including those before checkpoint
+      await component.init({ env: mockEnv, options: { configComponent, config: { storage: { type: "sqlite", dbPath: tempDbPath } } } });
+      const session = await component.create({ title: "Test" });
+
+      // Add 30 messages
+      for (let i = 0; i < 30; i++) {
+        await component.addMessage(session.id, { role: "user", content: `Message ${i}` });
+      }
+
+      // Add a checkpoint message
+      await component.addMessage(session.id, {
+        role: "user",
+        content: "# Checkpoint",
+        metadata: { isCheckpoint: true, checkpointId: "cp_test" }
+      });
+
+      // Add 40 more messages (total 71, with checkpoint)
+      for (let i = 30; i < 70; i++) {
+        await component.addMessage(session.id, { role: "user", content: `Message ${i}` });
+      }
+
+      const ctx = await component.getContext(session.id, { fullHistory: true });
+
+      // Should return ALL 71 messages
+      expect(ctx.messages.length).toBe(71);
+      expect(ctx.totalMessageCount).toBe(71);
+      expect(ctx.checkpoints.length).toBe(1);
+    });
+  });
+
+  describe("shouldCompact", () => {
+    test("should return false when messages below threshold", async () => {
+      await component.init({ 
+        env: mockEnv, 
+        options: { 
+          configComponent,
+          config: { 
+            maxMessages: 100,
+            storage: { type: "sqlite", dbPath: tempDbPath } 
+          }
+        } 
+      });
+      const session = await component.create({ title: "Test" });
+      await component.addMessage(session.id, { role: "user", content: "Hi" });
+
+      const result = await component.shouldCompact(session.id);
+
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe("SessionCheckpoint types", () => {
+  test("should have required checkpoint properties", () => {
+    // Test checkpoint structure
+    const checkpoint = {
+      id: "cp_test",
+      messageIndex: 0,
+      title: "Test Checkpoint",
+      createdAt: Date.now(),
+      type: "compact" as const,
+      summary: "Test summary",
+      processKeyPoints: ["Point 1", "Point 2"],
+      currentState: "Current state",
+      nextSteps: ["Next step"],
+      messageCountBefore: 10,
+      userIntents: [],  // New field
+    };
+
+    expect(checkpoint.id).toBe("cp_test");
+    expect(checkpoint.type).toBe("compact");
+    expect(Array.isArray(checkpoint.processKeyPoints)).toBe(true);
+    expect(typeof checkpoint.currentState).toBe("string");
+    expect(Array.isArray(checkpoint.userIntents)).toBe(true);
+  });
+
+  test("should support userIntents field in checkpoint", () => {
+    // Test that checkpoint supports userIntents
+    const checkpoint = {
+      id: "cp_test",
+      messageIndex: 0,
+      title: "Test Checkpoint",
+      createdAt: Date.now(),
+      type: "compact" as const,
+      summary: "Test summary",
+      processKeyPoints: [],
+      currentState: "Current state",
+      nextSteps: [],
+      messageCountBefore: 10,
+      userIntents: [
+        "Fix login bug",
+        "Optimize database query",
+        "Write unit tests"
+      ],
+    };
+
+    expect(checkpoint.userIntents).toBeDefined();
+    expect(checkpoint.userIntents.length).toBe(3);
+    expect(checkpoint.userIntents[0]).toBe("Fix login bug");
+    expect(checkpoint.userIntents).toContain("Optimize database query");
+  });
+
+  test("userIntents should be an array of strings", () => {
+    const checkpoint = {
+      id: "cp_test",
+      messageIndex: 0,
+      title: "Test",
+      createdAt: Date.now(),
+      type: "compact" as const,
+      summary: "",
+      processKeyPoints: [],
+      currentState: "",
+      nextSteps: [],
+      messageCountBefore: 0,
+      userIntents: ["Intent 1", "Intent 2", "Intent 3"],
+    };
+
+    checkpoint.userIntents.forEach(intent => {
+      expect(typeof intent).toBe("string");
+    });
+  });
+
+  test("userIntents can be empty", () => {
+    const checkpoint = {
+      id: "cp_test",
+      messageIndex: 0,
+      title: "Test",
+      createdAt: Date.now(),
+      type: "compact" as const,
+      summary: "",
+      processKeyPoints: [],
+      currentState: "",
+      nextSteps: [],
+      messageCountBefore: 0,
+      userIntents: [],
+    };
+
+    expect(checkpoint.userIntents).toEqual([]);
+  });
+
+  test("userIntents should have reasonable limit", () => {
+    // Intent descriptions should be concise
+    const checkpoint = {
+      id: "cp_test",
+      messageIndex: 0,
+      title: "Test",
+      createdAt: Date.now(),
+      type: "compact" as const,
+      summary: "",
+      processKeyPoints: [],
+      currentState: "",
+      nextSteps: [],
+      messageCountBefore: 0,
+      userIntents: [
+        "Fix auth module",
+        "Update dependencies"
+      ],
+    };
+
+    // Each intent should be a concise string (not too long)
+    checkpoint.userIntents.forEach(intent => {
+      expect(intent.length).toBeLessThan(200);
+    });
+  });
+});