@ai-setting/roy-agent-cli 1.0.0

package/src/commands/memory/record-prompt-component.test.ts

@@ -0,0 +1,343 @@
+/**
+ * @fileoverview TDD Test: record.ts should use PromptComponent for prompts
+ * 
+ * RED Phase: Write failing test
+ * 
+ * 验证 record.ts 应该：
+ * 1. 通过 PromptComponent 获取 prompt，而非直接调用 getBuiltInPrompt()
+ * 2. 确保 memory path 从配置读取
+ */
+
+import { describe, expect, test, vi, beforeEach, afterEach } from "vitest";
+import type { PromptComponent } from "@ai-setting/roy-agent-core";
+
+// Mock chalk
+vi.mock("chalk", () => ({
+  default: {
+    blue: (str: string) => str,
+    gray: (str: string) => str,
+    green: (str: string) => str,
+    red: (str: string) => str,
+    yellow: (str: string) => str,
+    cyan: (str: string) => str,
+    bold: (str: string) => str,
+  },
+}));
+
+describe("TDD: record.ts should use PromptComponent", () => {
+
+  // ========================================================================
+  // GREEN Phase: Minimal implementation to pass tests
+  // ========================================================================
+
+  /**
+   * Helper function to get prompt (simulates the desired implementation)
+   * 
+   * This should be the actual implementation in record.ts after GREEN phase
+   */
+  async function getPromptFromComponent(
+    env: any,
+    promptName: string
+  ): Promise<string> {
+    const promptComponent = env?.getComponent?.("prompt") as PromptComponent | undefined;
+    
+    if (promptComponent) {
+      return await promptComponent.getPrompt(promptName);
+    }
+    
+    // Fallback to getBuiltInPrompt if PromptComponent not available
+    const { getBuiltInPrompt } = await import("@ai-setting/roy-agent-core");
+    return getBuiltInPrompt(promptName) || "";
+  }
+
+  describe("GREEN: getPromptFromComponent implementation", () => {
+    
+    test("should get prompt from PromptComponent when available", async () => {
+      // Given: PromptComponent mock
+      const mockPromptComponent = {
+        getPrompt: vi.fn().mockResolvedValue("# Memory Agent Prompt\n\n{USER_REQUIREMENT}"),
+        has: vi.fn().mockReturnValue(true),
+      } as unknown as PromptComponent;
+
+      const mockEnv = {
+        getComponent: vi.fn().mockReturnValue(mockPromptComponent),
+      };
+
+      // When: Getting prompt
+      const prompt = await getPromptFromComponent(mockEnv, "project-memory");
+
+      // Then: Should be fetched via PromptComponent
+      expect(mockPromptComponent.getPrompt).toHaveBeenCalledWith("project-memory");
+      expect(prompt).toContain("{USER_REQUIREMENT}");
+    });
+
+    test("should fallback to getBuiltInPrompt when PromptComponent not available", async () => {
+      // Given: No PromptComponent
+      const mockEnv = {
+        getComponent: vi.fn().mockReturnValue(undefined),
+      };
+
+      // When: Getting prompt
+      const prompt = await getPromptFromComponent(mockEnv, "project-memory");
+
+      // Then: Should fallback to getBuiltInPrompt
+      expect(prompt).toBeDefined();
+      expect(prompt).toContain("项目记忆管理专家");
+    });
+
+    test("should support both project-memory and global-memory", async () => {
+      // Create a single mock PromptComponent with persistent mock
+      const mockGetPrompt = vi.fn()
+        .mockResolvedValueOnce("# Project Memory")
+        .mockResolvedValueOnce("# Global Memory");
+
+      const mockEnv = {
+        getComponent: vi.fn((name: string) => {
+          if (name === "prompt") {
+            return { getPrompt: mockGetPrompt };
+          }
+          return undefined;
+        }),
+      };
+
+      const projectPrompt = await getPromptFromComponent(mockEnv, "project-memory");
+      expect(projectPrompt).toBe("# Project Memory");
+
+      const globalPrompt = await getPromptFromComponent(mockEnv, "global-memory");
+      expect(globalPrompt).toBe("# Global Memory");
+    });
+
+  });
+
+  describe("Memory Path from Config (already working)", () => {
+    
+    test("should get memory paths from MemoryComponent.config.memoryPaths", async () => {
+      // Given: MemoryComponent with configured paths
+      const mockMemoryComponent = {
+        recallMemory: vi.fn().mockResolvedValue("# Project Memory\n\n暂无内容"),
+        getMemoryPaths: vi.fn().mockReturnValue([
+          { type: "project", path: ".roy/memory" },
+          { type: "user", path: "~/.config/roy-agent/memory" },
+        ]),
+        getMemoryFile: vi.fn().mockReturnValue("memory.md"),
+      };
+
+      // When: Getting paths for scope
+      const paths = mockMemoryComponent.getMemoryPaths();
+      const projectPath = paths.find(p => p.type === "project");
+
+      // Then: Should return configured paths, not hardcoded
+      expect(projectPath?.path).toBe(".roy/memory");
+      expect(mockMemoryComponent.getMemoryPaths).toHaveBeenCalled();
+    });
+
+    test("should map scope 'global' to type 'user' in memory paths", async () => {
+      const mockMemoryComponent = {
+        recallMemory: vi.fn().mockImplementation((scope?: "project" | "global") => {
+          if (scope === "global") {
+            return Promise.resolve("# Global Memory\n\nUser preferences");
+          }
+          return Promise.resolve("# Project Memory\n\nProject settings");
+        }),
+        getMemoryPaths: vi.fn().mockReturnValue([
+          { type: "project", path: ".roy/memory" },
+          { type: "user", path: "~/.config/roy-agent/memory" },
+        ]),
+      };
+
+      const globalMemory = await mockMemoryComponent.recallMemory("global");
+      expect(globalMemory).toContain("User preferences");
+      expect(globalMemory).toContain("Global Memory");
+    });
+
+  });
+
+  describe("Integration: Full prompt flow with PromptComponent", () => {
+    
+    test("should fetch prompt from PromptComponent and replace variables", async () => {
+      // Given: PromptComponent with prompt template
+      const promptTemplate = `# Memory Agent
+Scope: {SCOPE}
+User Requirement: {USER_REQUIREMENT}
+Existing Memory: {CURRENT_MEMORY}`;
+
+      const mockPromptComponent = {
+        getPrompt: vi.fn().mockResolvedValue(promptTemplate),
+      } as unknown as PromptComponent;
+
+      const mockMemoryComponent = {
+        recallMemory: vi.fn().mockResolvedValue("# Previous memory content"),
+      };
+
+      // When: Building final prompt
+      const rawPrompt = await mockPromptComponent.getPrompt("project-memory");
+      const userRequirement = "Extract key project information";
+      const currentMemory = await mockMemoryComponent.recallMemory("project");
+
+      const finalPrompt = rawPrompt
+        .replace("{USER_REQUIREMENT}", userRequirement)
+        .replace("{SCOPE}", "project")
+        .replace("{CURRENT_MEMORY}", currentMemory || "(无现有记忆)");
+
+      // Then: Should have all variables replaced
+      expect(finalPrompt).toContain("Extract key project information");
+      expect(finalPrompt).toContain("project");
+      expect(finalPrompt).toContain("Previous memory content");
+      expect(finalPrompt).not.toContain("{USER_REQUIREMENT}");
+      expect(finalPrompt).not.toContain("{SCOPE}");
+    });
+
+    test("should use same pattern as default agent for consistency", async () => {
+      // The default agent uses: promptComponent.getPrompt("default")
+      // Memory agent should use: promptComponent.getPrompt("project-memory") or "global-memory"
+      
+      const mockPromptComponent = {
+        getPrompt: vi.fn()
+          .mockResolvedValueOnce("Default Agent Prompt")
+          .mockResolvedValueOnce("Project Memory Prompt"),
+      } as unknown as PromptComponent;
+
+      // Default agent pattern
+      const defaultPrompt = await mockPromptComponent.getPrompt("default");
+      expect(mockPromptComponent.getPrompt).toHaveBeenNthCalledWith(1, "default");
+
+      // Memory agent pattern (should be consistent)
+      const memoryPrompt = await mockPromptComponent.getPrompt("project-memory");
+      expect(mockPromptComponent.getPrompt).toHaveBeenNthCalledWith(2, "project-memory");
+
+      expect(defaultPrompt).toBeDefined();
+      expect(memoryPrompt).toBeDefined();
+    });
+
+  });
+
+  describe("Environment integration", () => {
+    
+    test("should get PromptComponent from env.getComponent('prompt')", async () => {
+      // Given: Mock environment with PromptComponent
+      const mockPromptComponent = {
+        getPrompt: vi.fn().mockResolvedValue("# Test Prompt"),
+        has: vi.fn().mockReturnValue(true),
+      } as unknown as PromptComponent;
+
+      const mockEnv = {
+        getComponent: vi.fn((name: string) => {
+          if (name === "prompt") return mockPromptComponent;
+          if (name === "memory") return {
+            recallMemory: vi.fn().mockResolvedValue(""),
+            getMemoryPaths: vi.fn().mockReturnValue([]),
+          };
+          return undefined;
+        }),
+      };
+
+      // When: Getting prompt component from env
+      const promptComponent = mockEnv.getComponent("prompt") as PromptComponent;
+      const prompt = await promptComponent.getPrompt("project-memory");
+
+      // Then: Should work via env
+      expect(mockEnv.getComponent).toHaveBeenCalledWith("prompt");
+      expect(promptComponent.getPrompt).toHaveBeenCalledWith("project-memory");
+      expect(prompt).toBeDefined();
+    });
+
+    test("should handle missing PromptComponent gracefully", async () => {
+      // Given: Environment without PromptComponent
+      const mockEnv = {
+        getComponent: vi.fn().mockReturnValue(undefined),
+      };
+
+      // When: Trying to get PromptComponent
+      const promptComponent = mockEnv.getComponent("prompt");
+
+      // Then: Should handle gracefully (fallback to getBuiltInPrompt)
+      expect(promptComponent).toBeUndefined();
+      
+      // Fallback should work
+      const { getBuiltInPrompt } = await import("@ai-setting/roy-agent-core");
+      const fallbackPrompt = getBuiltInPrompt("project-memory");
+      expect(fallbackPrompt).toBeDefined();
+    });
+
+  });
+
+  // ========================================================================
+  // REFACTOR Phase: Verify implementation matches expected pattern
+  // ========================================================================
+
+  describe("REFACTOR: Verify record.ts implementation pattern", () => {
+    
+    test("record.ts should follow getPromptFromComponent pattern", async () => {
+      // This test verifies that the helper function matches expected pattern
+      // After GREEN phase, record.ts should be refactored to use this pattern
+
+      // Mock environment with all required components
+      const mockMemoryComponent = {
+        recallMemory: vi.fn().mockResolvedValue("# Existing memory"),
+        getMemoryPaths: vi.fn().mockReturnValue([
+          { type: "project", path: ".roy/memory" },
+        ]),
+        getMemoryFile: vi.fn().mockReturnValue("memory.md"),
+      };
+
+      const mockPromptComponent = {
+        getPrompt: vi.fn().mockResolvedValue("# Memory Agent Prompt"),
+        has: vi.fn().mockReturnValue(true),
+      } as unknown as PromptComponent;
+
+      const mockEnv = {
+        getComponent: vi.fn((name: string) => {
+          if (name === "prompt") return mockPromptComponent;
+          if (name === "memory") return mockMemoryComponent;
+          return undefined;
+        }),
+      };
+
+      // Simulate what record.ts should do after refactoring
+      const scope = "project";
+      const promptName = `${scope}-memory`;
+      
+      // Get prompt via PromptComponent (NEW pattern)
+      const prompt = await getPromptFromComponent(mockEnv, promptName);
+      
+      // Get memory via MemoryComponent (already correct)
+      const currentMemory = await mockMemoryComponent.recallMemory(scope);
+
+      // Verify
+      expect(mockPromptComponent.getPrompt).toHaveBeenCalledWith(promptName);
+      expect(mockMemoryComponent.recallMemory).toHaveBeenCalledWith(scope);
+      expect(prompt).toBeDefined();
+      expect(currentMemory).toBeDefined();
+    });
+
+    test("record.ts should NOT call getBuiltInPrompt directly", async () => {
+      // This test documents the expected behavior
+      // After GREEN phase, record.ts should NOT import getBuiltInPrompt directly
+
+      // OLD pattern (should be removed):
+      // import { getBuiltInPrompt } from "@ai-setting/roy-agent-core";
+      // const prompt = getBuiltInPrompt("project-memory");
+
+      // NEW pattern (should be used):
+      // const prompt = await promptComponent.getPrompt("project-memory");
+
+      // Verify the NEW pattern works
+      const mockEnv = {
+        getComponent: vi.fn((name: string) => {
+          if (name === "prompt") {
+            return {
+              getPrompt: vi.fn().mockResolvedValue("# Memory Agent"),
+            };
+          }
+          return undefined;
+        }),
+      };
+
+      const prompt = await getPromptFromComponent(mockEnv, "project-memory");
+      expect(prompt).toBe("# Memory Agent");
+      expect(mockEnv.getComponent).toHaveBeenCalledWith("prompt");
+    });
+
+  });
+
+});

package/src/commands/memory/record.test.ts

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Memory Record Command Tests (TDD)
+ * 
+ * TDD 测试：record 命令的 --extract 功能
+ */
+
+import { describe, expect, test, vi } from "vitest";
+import { RecordCommand } from "./record";
+
+describe("RecordCommand", () => {
+  describe("command configuration", () => {
+    test("should have correct command name", () => {
+      expect(RecordCommand.command).toBe("record");
+    });
+
+    test("should have aliases", () => {
+      expect(RecordCommand.aliases).toContain("save");
+    });
+
+    test("should have description", () => {
+      expect(RecordCommand.describe).toBe("记录记忆内容到 memory file");
+    });
+  });
+
+  describe("RecordOptions interface", () => {
+    test("should include extract option", () => {
+      const options: any = {
+        mode: "append",
+        extract: true,
+        scope: "global",
+        "session-id": "session-abc-123",
+        require: "提取项目配置信息",
+      };
+
+      expect(options.extract).toBe(true);
+      expect(options.scope).toBe("global");
+      expect(options["session-id"]).toBe("session-abc-123");
+      expect(options.require).toBe("提取项目配置信息");
+    });
+
+    test("scope should accept both project and global", () => {
+      const projectOptions = { scope: "project" as const };
+      const globalOptions = { scope: "global" as const };
+
+      expect(projectOptions.scope).toBe("project");
+      expect(globalOptions.scope).toBe("global");
+    });
+
+    test("mode should accept standard modes", () => {
+      const modes = ["append", "prepend", "overwrite", "delete"];
+      modes.forEach(mode => {
+        expect(["append", "prepend", "overwrite", "delete"]).toContain(mode);
+      });
+    });
+
+    test("should support extract mode", () => {
+      const extractOptions = {
+        extract: true,
+        scope: "project" as const,
+        "session-id": "test-session",
+        require: "重点关注配置信息",
+      };
+
+      expect(extractOptions.extract).toBe(true);
+      expect(extractOptions.scope).toBe("project");
+    });
+  });
+
+  describe("extract functionality", () => {
+    test("extract mode should not require content", () => {
+      // Extract 模式下，不需要提供 content
+      const extractOnly = {
+        extract: true,
+        mode: "append" as const,
+      };
+
+      expect(extractOnly.extract).toBe(true);
+      // 不需要 content 属性
+      expect((extractOnly as any).content).toBeUndefined();
+    });
+
+    test("non-extract mode requires content for non-delete", () => {
+      // 普通模式下，mode 不是 delete 时需要 content
+      const normalMode = {
+        mode: "append" as const,
+        content: "Some memory content",
+      };
+
+      expect(normalMode.content).toBeDefined();
+    });
+  });
+});