@ai-setting/roy-agent-core 1.0.0

package/src/env/task/storage/task-search.test.ts

@@ -0,0 +1,291 @@
+/**
+ * @fileoverview Tests for TaskStore searchTasksByKeywords functionality
+ */
+
+import { describe, test, expect, beforeEach } from "bun:test";
+import { SQLiteTaskStore } from "./sqlite-task-store";
+
+describe("TaskStore.searchTasks with keywords", () => {
+  let store: SQLiteTaskStore;
+
+  beforeEach(async () => {
+    store = new SQLiteTaskStore(":memory:");
+  });
+
+  // ========================================================================
+  // 基本搜索
+  // ========================================================================
+
+  test("should find tasks by keyword (single keyword)", async () => {
+    // Create tasks
+    await store.createTask({
+      title: "Fix login bug",
+      description: "Login page has issues",
+      tags: ["bug", "authentication"],
+      sessionId: "test",
+    });
+    await store.createTask({
+      title: "Add new feature",
+      description: "Implement new feature",
+      tags: ["feature"],
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasksByKeywords(["login"]);
+
+    expect(results.length).toBe(1);
+    expect(results[0].title).toBe("Fix login bug");
+  });
+
+  test("should support multi-keyword AND search", async () => {
+    await store.createTask({
+      title: "Fix login bug",
+      description: "Login page has issues",
+      tags: ["bug", "authentication"],
+      sessionId: "test",
+    });
+    await store.createTask({
+      title: "Fix register bug",
+      description: "Register page has issues",
+      tags: ["bug"],
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasksByKeywords(["fix", "login"]);
+
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    expect(results[0].title).toContain("login");
+  });
+
+  // ========================================================================
+  // 关键字列表搜索
+  // ========================================================================
+
+  test("should support keywords array parameter", async () => {
+    await store.createTask({
+      title: "Implement user authentication",
+      description: "User login and logout",
+      tags: ["auth", "security"],
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasksByKeywords(["auth", "user", "security"]);
+
+    expect(results.length).toBe(1);
+    expect(results[0].title).toContain("authentication");
+  });
+
+  test("should search in tags field", async () => {
+    await store.createTask({
+      title: "Task 1",
+      description: "Description",
+      tags: ["typescript", "backend"],
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasksByKeywords(["typescript"]);
+
+    expect(results.length).toBe(1);
+    expect(results[0].tags).toContain("typescript");
+  });
+
+  test("should search in description field", async () => {
+    await store.createTask({
+      title: "Task without keyword in title",
+      description: "This is about database optimization",
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasksByKeywords(["database"]);
+
+    expect(results.length).toBe(1);
+    expect(results[0].description).toContain("database");
+  });
+
+  test("should search in goals_and_expected_deliverables field", async () => {
+    await store.createTask({
+      title: "Task without keyword in title",
+      description: "General description",
+      goals_and_expected_deliverables: "Improve API performance by 50%",
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasksByKeywords(["performance"]);
+
+    expect(results.length).toBe(1);
+    expect(results[0].goals_and_expected_deliverables).toContain("performance");
+  });
+
+  test("should search in operation records", async () => {
+    const task = await store.createTask({
+      title: "Task with operation",
+      description: "Description",
+      sessionId: "test",
+    });
+
+    await store.createOperation({
+      taskId: task.id,
+      sessionId: "test",
+      actionType: "solution",
+      actionTitle: "Implemented caching mechanism",
+      actionDescription: "Added Redis caching for API responses",
+    });
+
+    const results = await store.searchTasksByKeywords(["caching", "redis"]);
+
+    expect(results.length).toBe(1);
+    expect(results[0].id).toBe(task.id);
+  });
+
+  test("should exclude specified task ID", async () => {
+    const task1 = await store.createTask({
+      title: "Duplicate task",
+      description: "Same description",
+      tags: ["test"],
+      sessionId: "test",
+    });
+    await store.createTask({
+      title: "Another task",
+      description: "Same description",
+      tags: ["test"],
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasksByKeywords(["test"], { excludeTaskId: task1.id });
+
+    expect(results.length).toBe(1);
+    expect(results[0].id).not.toBe(task1.id);
+  });
+
+  test("should support limit parameter", async () => {
+    // Create 5 tasks with same tag
+    for (let i = 0; i < 5; i++) {
+      await store.createTask({
+        title: `Task ${i}`,
+        description: "Same description with keyword",
+        tags: ["test"],
+        sessionId: "test",
+      });
+    }
+
+    const results = await store.searchTasksByKeywords(["keyword"], { limit: 2 });
+
+    expect(results.length).toBeLessThanOrEqual(2);
+  });
+
+  // ========================================================================
+  // 类似任务查找
+  // ========================================================================
+
+  test("should find similar tasks by tags", async () => {
+    const task1 = await store.createTask({
+      title: "Task 1",
+      description: "Description",
+      tags: ["bug", "backend"],
+      sessionId: "test",
+    });
+    const task2 = await store.createTask({
+      title: "Task 2",
+      description: "Description",
+      tags: ["bug", "frontend"],
+      sessionId: "test",
+    });
+    await store.createTask({
+      title: "Task 3",
+      description: "Description",
+      tags: ["feature"],
+      sessionId: "test",
+    });
+
+    const results = await store.findSimilarTasksByKeywords(["bug"], { excludeTaskId: task1.id });
+
+    expect(results.length).toBe(1);
+    expect(results[0].id).toBe(task2.id);
+  });
+
+  test("should exclude itself from results", async () => {
+    const task = await store.createTask({
+      title: "My task",
+      description: "My description",
+      tags: ["test"],
+      sessionId: "test",
+    });
+
+    const results = await store.findSimilarTasksByKeywords(["test"], { excludeTaskId: task.id });
+
+    expect(results.length).toBe(0);
+  });
+
+  test("should sort by relevance", async () => {
+    const task1 = await store.createTask({
+      title: "Task 1",
+      description: "Description with bug",
+      tags: ["bug"],
+      sessionId: "test",
+    });
+    const task2 = await store.createTask({
+      title: "Task 2",
+      description: "Description",
+      tags: ["bug", "backend", "api"],
+      sessionId: "test",
+    });
+
+    const results = await store.findSimilarTasksByKeywords(["bug", "backend"]);
+
+    // Task2 has more matches (3 tags vs 1)
+    expect(results[0].id).toBe(task2.id);
+    expect(results[1].id).toBe(task1.id);
+  });
+
+  // ========================================================================
+  // 向后兼容
+  // ========================================================================
+
+  test("original query parameter should still work", async () => {
+    await store.createTask({
+      title: "Login feature",
+      description: "Implement login",
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasks("login");
+
+    expect(results.length).toBe(1);
+    expect(results[0].title).toContain("Login");
+  });
+
+  // ========================================================================
+  // 边界情况
+  // ========================================================================
+
+  test("should return empty array when no results", async () => {
+    const results = await store.searchTasksByKeywords(["nonexistent"]);
+
+    expect(results.length).toBe(0);
+  });
+
+  test("should return empty array for empty keywords list", async () => {
+    await store.createTask({
+      title: "Test task",
+      description: "Description",
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasksByKeywords([]);
+
+    expect(results.length).toBe(0);
+  });
+
+  test("should handle case insensitivity", async () => {
+    await store.createTask({
+      title: "BUG FIX",
+      description: "Description",
+      tags: ["BACKEND"],
+      sessionId: "test",
+    });
+
+    const results = await store.searchTasksByKeywords(["bug", "backend"]);
+
+    expect(results.length).toBe(1);
+  });
+});

package/src/env/task/tag-service.test.ts

@@ -0,0 +1,198 @@
+/**
+ * @fileoverview TagService Tests
+ */
+
+import { describe, test, expect, beforeEach } from "vitest";
+import { DefaultTagService } from "./tag-service";
+import { SQLiteTaskStore } from "./storage/sqlite-task-store";
+import type { TaskStore } from "./storage/sqlite-task-store";
+
+describe("TagService", () => {
+  let store: TaskStore;
+  let tagService: DefaultTagService;
+
+  beforeEach(() => {
+    store = new SQLiteTaskStore(":memory:");
+    tagService = new DefaultTagService(store);
+  });
+
+  describe("Tag CRUD", () => {
+    test("should create a tag", async () => {
+      const tag = await tagService.createTag("bug");
+      
+      expect(tag.id).toBeDefined();
+      expect(tag.name).toBe("bug");
+      expect(tag.taskCount).toBe(0);
+    });
+
+    test("should return existing tag if name already exists", async () => {
+      const tag1 = await tagService.createTag("feature");
+      const tag2 = await tagService.createTag("feature");
+      
+      expect(tag1.id).toBe(tag2.id);
+      expect(tag2.name).toBe("feature");
+    });
+
+    test("should get tag by id", async () => {
+      const created = await tagService.createTag("docs");
+      const retrieved = await tagService.getTag(created.id);
+      
+      expect(retrieved?.name).toBe("docs");
+    });
+
+    test("should get tag by name", async () => {
+      await tagService.createTag("refactor");
+      const tag = await tagService.getTagByName("refactor");
+      
+      expect(tag?.name).toBe("refactor");
+    });
+
+    test("should list tags ordered by count", async () => {
+      await tagService.createTag("tag1");
+      await tagService.createTag("tag2");
+      await tagService.createTag("tag3");
+      
+      const tags = await tagService.listTags({ orderBy: "count" });
+      
+      expect(tags).toHaveLength(3);
+      expect(tags[0].name).toBe("tag1");
+    });
+
+    test("should search tags by name", async () => {
+      await tagService.createTag("bug");
+      await tagService.createTag("bug-fix");
+      await tagService.createTag("feature");
+      
+      const results = await tagService.searchTags({ query: "bug" });
+      
+      expect(results.length).toBeGreaterThanOrEqual(2);
+      expect(results.some(t => t.name === "bug")).toBe(true);
+      expect(results.some(t => t.name === "bug-fix")).toBe(true);
+    });
+
+    test("should delete tag", async () => {
+      const tag = await tagService.createTag("to-delete");
+      const result = await tagService.deleteTag(tag.id);
+      
+      expect(result).toBe(true);
+      expect(await tagService.getTag(tag.id)).toBeUndefined();
+    });
+  });
+
+  describe("Tag and Task Association", () => {
+    test("should add tags to task", async () => {
+      // Create task first
+      const task = await store.createTask({
+        title: "Test Task",
+        sessionId: "test-session",
+      });
+      
+      const tag1 = await tagService.createTag("frontend");
+      const tag2 = await tagService.createTag("ui");
+      
+      await tagService.addTagsToTask(task.id, [tag1.id, tag2.id]);
+      
+      const tags = await tagService.getTagsForTask(task.id);
+      expect(tags).toHaveLength(2);
+      expect(tags.map(t => t.name)).toContain("frontend");
+      expect(tags.map(t => t.name)).toContain("ui");
+    });
+
+    test("should remove tags from task", async () => {
+      const task = await store.createTask({
+        title: "Test Task",
+        sessionId: "test-session",
+      });
+      
+      const tag = await tagService.createTag("test");
+      await tagService.addTagsToTask(task.id, [tag.id]);
+      await tagService.removeTagsFromTask(task.id, [tag.id]);
+      
+      const tags = await tagService.getTagsForTask(task.id);
+      expect(tags).toHaveLength(0);
+    });
+
+    test("should get task IDs by tag names", async () => {
+      const task1 = await store.createTask({
+        title: "Task 1",
+        sessionId: "test-session",
+      });
+      const task2 = await store.createTask({
+        title: "Task 2",
+        sessionId: "test-session",
+      });
+      
+      const tag = await tagService.createTag("common");
+      await tagService.addTagsToTask(task1.id, [tag.id]);
+      await tagService.addTagsToTask(task2.id, [tag.id]);
+      
+      const taskIds = await tagService.getTaskIdsByTags(["common"]);
+      
+      expect(taskIds).toContain(task1.id);
+      expect(taskIds).toContain(task2.id);
+    });
+
+    test("should sync tags to task", async () => {
+      const task = await store.createTask({
+        title: "Test Task",
+        sessionId: "test-session",
+      });
+      
+      await tagService.syncTagsToTask(task.id, ["new-tag1", "new-tag2"]);
+      
+      const tags = await tagService.getTagsForTask(task.id);
+      expect(tags).toHaveLength(2);
+      expect(tags.map(t => t.name)).toContain("new-tag1");
+      expect(tags.map(t => t.name)).toContain("new-tag2");
+    });
+  });
+
+  describe("Retrieval Capabilities", () => {
+    // TODO: Skip until findSimilarTasks is implemented
+    test.skip("should find similar tasks by tags", async () => {
+      const task1 = await store.createTask({
+        title: "Task 1",
+        sessionId: "test-session",
+      });
+      const task2 = await store.createTask({
+        title: "Task 2",
+        sessionId: "test-session",
+      });
+      const task3 = await store.createTask({
+        title: "Task 3",
+        sessionId: "test-session",
+      });
+      
+      const tag1 = await tagService.createTag("bug");
+      const tag2 = await tagService.createTag("frontend");
+      
+      await tagService.addTagsToTask(task1.id, [tag1.id, tag2.id]);
+      await tagService.addTagsToTask(task2.id, [tag1.id]);
+      await tagService.addTagsToTask(task3.id, [tag2.id]);
+      
+      const similar = await tagService.findSimilarTasks(task1.id, 5);
+      
+      // Should find task2 (1 tag match) before task3 (0 tag match)
+      expect(similar.length).toBeGreaterThan(0);
+      expect(similar[0].id).toBe(task2.id);
+    });
+
+    test("should search tasks by query", async () => {
+      await store.createTask({
+        title: "Fix login bug",
+        description: "Users cannot login",
+        sessionId: "test-session",
+      });
+      await store.createTask({
+        title: "Add feature",
+        description: "New feature request",
+        sessionId: "test-session",
+      });
+      
+      const results = await tagService.searchTasks("login");
+      
+      expect(results.length).toBe(1);
+      expect(results[0].title).toContain("login");
+    });
+  });
+});