@ai-setting/roy-agent-core 1.3.9 → 1.3.11

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

@@ -1,523 +0,0 @@
-/**
- * @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);
-    });
-  });
-});