@ai-setting/roy-agent-cli 1.3.15 → 1.3.16

package/dist/core/src/env/task/storage/sqlite-task-store.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview SQLite Task Store Tests
+ */
+export {};
+//# sourceMappingURL=sqlite-task-store.test.d.ts.map

package/dist/core/src/env/task/storage/sqlite-task-store.test.js

@@ -0,0 +1,235 @@
+/**
+ * @fileoverview SQLite Task Store Tests
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { SQLiteTaskStore } from "./sqlite-task-store.js";
+import { tmpdir } from "os";
+import { join } from "path";
+describe("SQLiteTaskStore", () => {
+    let store;
+    beforeEach(async () => {
+        // 每个测试使用唯一的数据库路径，确保隔离
+        const testDbPath = join(tmpdir(), `task-store-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+        store = new SQLiteTaskStore(testDbPath);
+    });
+    afterEach(async () => {
+        await store.close();
+    });
+    describe("createTask", () => {
+        it("should create a task with required fields", async () => {
+            const task = await store.createTask({
+                title: "Test Task",
+                sessionId: "sess_123",
+            });
+            expect(task.id).toBeGreaterThan(0);
+            expect(task.title).toBe("Test Task");
+            expect(task.status).toBe("todo");
+            expect(task.priority).toBe("medium");
+        });
+        it("should create task with all options", async () => {
+            const task = await store.createTask({
+                title: "Full Task",
+                description: "Description",
+                priority: "high",
+                sessionId: "sess_123",
+                tags: ["feature", "urgent"],
+            });
+            expect(task.description).toBe("Description");
+            expect(task.priority).toBe("high");
+            expect(task.tags).toEqual(["feature", "urgent"]);
+        });
+    });
+    describe("CRUD operations", () => {
+        it("should perform full CRUD cycle", async () => {
+            // Create
+            const created = await store.createTask({ title: "CRUD Test", sessionId: "sess_123" });
+            expect(created.id).toBeGreaterThan(0);
+            // Read
+            const read = await store.getTask(created.id);
+            expect(read?.title).toBe("CRUD Test");
+            // Update
+            const updated = await store.updateTask(created.id, { status: "active", progress: 50 });
+            expect(updated?.status).toBe("active");
+            expect(updated?.progress).toBe(50);
+            // Delete
+            const deleted = await store.deleteTask(created.id);
+            expect(deleted).toBe(true);
+            const notFound = await store.getTask(created.id);
+            expect(notFound).toBeUndefined();
+        });
+        it("should update current_status field", async () => {
+            const task = await store.createTask({ title: "Test", sessionId: "sess_123" });
+            const updated = await store.updateTask(task.id, {
+                current_status: "正在实现登录功能"
+            });
+            expect(updated?.current_status).toBe("正在实现登录功能");
+        });
+    });
+    describe("operations", () => {
+        it("should create and list operations", async () => {
+            const task = await store.createTask({ title: "Task", sessionId: "sess_123" });
+            await store.createOperation({
+                taskId: task.id,
+                sessionId: "sess_123",
+                actionType: "create",
+                actionTitle: "Task created",
+            });
+            await store.createOperation({
+                taskId: task.id,
+                sessionId: "sess_456", // different session!
+                actionType: "progress",
+                actionTitle: "Made progress",
+            });
+            const ops = await store.listOperations({ taskId: task.id });
+            expect(ops.length).toBe(2);
+        });
+        it("should track sessionId for each operation", async () => {
+            const task = await store.createTask({ title: "Task", sessionId: "sess_1" });
+            await store.createOperation({
+                taskId: task.id,
+                sessionId: "sess_1",
+                actionType: "create",
+                actionTitle: "Started in session 1",
+            });
+            await store.createOperation({
+                taskId: task.id,
+                sessionId: "sess_2",
+                actionType: "progress",
+                actionTitle: "Continued in session 2",
+            });
+            await store.createOperation({
+                taskId: task.id,
+                sessionId: "sess_3",
+                actionType: "milestone",
+                actionTitle: "Reached milestone in session 3",
+            });
+            const ops = await store.listOperations({ taskId: task.id });
+            const sessions = new Set(ops.map(op => op.sessionId));
+            expect(sessions.has("sess_1")).toBe(true);
+            expect(sessions.has("sess_2")).toBe(true);
+            expect(sessions.has("sess_3")).toBe(true);
+        });
+        it("should filter operations by action type", async () => {
+            const task = await store.createTask({ title: "Task", sessionId: "sess_1" });
+            await store.createOperation({
+                taskId: task.id,
+                sessionId: "sess_1",
+                actionType: "create",
+                actionTitle: "Created",
+            });
+            await store.createOperation({
+                taskId: task.id,
+                sessionId: "sess_2",
+                actionType: "progress",
+                actionTitle: "Progress 1",
+            });
+            await store.createOperation({
+                taskId: task.id,
+                sessionId: "sess_3",
+                actionType: "progress",
+                actionTitle: "Progress 2",
+            });
+            const progressOps = await store.listOperations({
+                taskId: task.id,
+                actionType: "progress"
+            });
+            expect(progressOps.length).toBe(2);
+            expect(progressOps.every(op => op.actionType === "progress")).toBe(true);
+        });
+        it("should support pagination", async () => {
+            const task = await store.createTask({ title: "Task", sessionId: "sess_1" });
+            // Create 5 operations
+            for (let i = 0; i < 5; i++) {
+                await store.createOperation({
+                    taskId: task.id,
+                    sessionId: `sess_${i}`,
+                    actionType: "progress",
+                    actionTitle: `Progress ${i}`,
+                });
+            }
+            // Get first 2
+            const firstPage = await store.listOperations({
+                taskId: task.id,
+                limit: 2,
+                offset: 0
+            });
+            expect(firstPage.length).toBe(2);
+            // Get next 2
+            const secondPage = await store.listOperations({
+                taskId: task.id,
+                limit: 2,
+                offset: 2
+            });
+            expect(secondPage.length).toBe(2);
+        });
+    });
+    describe("listTasks", () => {
+        it("should list tasks with default order", async () => {
+            await store.createTask({ title: "Task 1", sessionId: "sess_1" });
+            await store.createTask({ title: "Task 2", sessionId: "sess_1" });
+            const tasks = await store.listTasks();
+            expect(tasks.length).toBe(2);
+        });
+        it("should filter by status", async () => {
+            const task1 = await store.createTask({ title: "Active Task", sessionId: "sess_1" });
+            const task2 = await store.createTask({ title: "Todo Task", sessionId: "sess_1" });
+            await store.updateTask(task1.id, { status: "active" });
+            const activeTasks = await store.listTasks({ status: "active" });
+            expect(activeTasks.length).toBe(1);
+            expect(activeTasks[0].title).toBe("Active Task");
+        });
+        it("should filter by priority", async () => {
+            const task1 = await store.createTask({ title: "High Task", sessionId: "sess_1", priority: "high" });
+            const task2 = await store.createTask({ title: "Low Task", sessionId: "sess_1", priority: "low" });
+            const highTasks = await store.listTasks({ priority: "high" });
+            expect(highTasks.length).toBe(1);
+            expect(highTasks[0].title).toBe("High Task");
+        });
+    });
+    describe("searchTasksByKeywords", () => {
+        it("should limit results to specified limit", async () => {
+            // Create 10 tasks with same tag
+            for (let i = 0; i < 10; i++) {
+                await store.createTask({
+                    title: `Task ${i}`,
+                    sessionId: "sess_1",
+                    tags: ["test-tag"],
+                });
+            }
+            // Search with limit=5
+            const results = await store.searchTasksByKeywords(["test-tag"], { limit: 5 });
+            expect(results.length).toBe(5);
+        });
+        it("should limit findSimilarTasksByKeywords to 5 by default", async () => {
+            // Create 10 tasks with same tag
+            for (let i = 0; i < 10; i++) {
+                await store.createTask({
+                    title: `Similar Task ${i}`,
+                    sessionId: "sess_1",
+                    tags: ["feature"],
+                });
+            }
+            // Search without explicit limit - should use default 5
+            const results = await store.findSimilarTasksByKeywords(["feature"]);
+            expect(results.length).toBe(5);
+        });
+        it("should exclude specified taskId", async () => {
+            const targetTask = await store.createTask({
+                title: "Target Task",
+                sessionId: "sess_1",
+                tags: ["bug"],
+            });
+            // Create some similar tasks
+            await store.createTask({ title: "Bug 1", sessionId: "sess_1", tags: ["bug"] });
+            await store.createTask({ title: "Bug 2", sessionId: "sess_1", tags: ["bug"] });
+            // Search excluding target task
+            const results = await store.searchTasksByKeywords(["bug"], {
+                limit: 10,
+                excludeTaskId: targetTask.id
+            });
+            // Should not contain target task
+            expect(results.some(t => t.id === targetTask.id)).toBe(false);
+        });
+    });
+});
+//# sourceMappingURL=sqlite-task-store.test.js.map

package/dist/core/src/env/task/storage/task-search.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Tests for TaskStore searchTasksByKeywords functionality
+ */
+export {};
+//# sourceMappingURL=task-search.test.d.ts.map

package/dist/core/src/env/task/storage/task-search.test.js

@@ -0,0 +1,236 @@
+/**
+ * @fileoverview Tests for TaskStore searchTasksByKeywords functionality
+ */
+import { describe, test, expect, beforeEach } from "bun:test";
+import { SQLiteTaskStore } from "./sqlite-task-store.js";
+describe("TaskStore.searchTasks with keywords", () => {
+    let store;
+    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);
+    });
+});
+//# sourceMappingURL=task-search.test.js.map

package/dist/core/src/env/task/tag-service.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview TagService - Tag 池管理服务
+ *
+ * 提供 Tag 的 CRUD、Tag 与 Task 关联、类似任务检索能力
+ *
+ * 设计原则：
+ * - Tag 池模式：新 Tag 从池中选取，无合适则新增
+ * - 混合存储：Task.tags JSON 快速读取 + Tag 表高效检索
+ */
+import type { Task, TaskTag } from "./types";
+import type { TaskStore } from "./storage/sqlite-task-store";
+export interface ListTagsOptions {
+    limit?: number;
+    offset?: number;
+    orderBy?: "count" | "name" | "created_at";
+}
+export interface SearchTagsOptions {
+    query: string;
+    limit?: number;
+}
+export interface TagService {
+    /**
+     * 创建 Tag（如果已存在则返回现有 Tag）
+     */
+    createTag(name: string): Promise<TaskTag>;
+    /**
+     * 获取 Tag by ID
+     */
+    getTag(id: number): Promise<TaskTag | undefined>;
+    /**
+     * 获取 Tag by Name
+     */
+    getTagByName(name: string): Promise<TaskTag | undefined>;
+    /**
+     * 列出所有 Tag
+     */
+    listTags(options?: ListTagsOptions): Promise<TaskTag[]>;
+    /**
+     * 搜索 Tag（模糊匹配）
+     */
+    searchTags(options: SearchTagsOptions): Promise<TaskTag[]>;
+    /**
+     * 删除 Tag（同时删除所有关联）
+     */
+    deleteTag(id: number): Promise<boolean>;
+    /**
+     * 给 Task 添加 Tags
+     */
+    addTagsToTask(taskId: number, tagIds: number[]): Promise<void>;
+    /**
+     * 从 Task 移除 Tags
+     */
+    removeTagsFromTask(taskId: number, tagIds: number[]): Promise<void>;
+    /**
+     * 获取 Task 的所有 Tags
+     */
+    getTagsForTask(taskId: number): Promise<TaskTag[]>;
+    /**
+     * 根据 Tag 名称获取关联的 Task IDs
+     */
+    getTaskIdsByTags(tagNames: string[]): Promise<number[]>;
+    /**
+     * 根据关键词列表搜索 Task（检索 tags、description、goals、operations）
+     * 这是新的核心检索方法
+     */
+    searchTasksByKeywords(keywords: string[], options?: {
+        limit?: number;
+        excludeTaskId?: number;
+    }): Promise<Task[]>;
+    /**
+     * 根据关键词查找类似 Task（排除自身，按相关性排序）
+     * 这是新的核心检索方法
+     */
+    findSimilarTasksByKeywords(keywords: string[], options?: {
+        limit?: number;
+        excludeTaskId?: number;
+    }): Promise<Task[]>;
+    /**
+     * 同步 Tags 到 Task（根据 tag 名称列表）
+     * - 查找或创建 Tag
+     * - 更新关联关系
+     * - 更新 task.tags JSON 字段
+     */
+    syncTagsToTask(taskId: number, tagNames: string[]): Promise<void>;
+    /**
+     * 查找类似 Task（基于 Tag 匹配度）- 原始实现，保留兼容
+     * @deprecated 使用 findSimilarTasksByKeywords 代替
+     */
+    findSimilarTasks(taskId: number, limit?: number): Promise<Task[]>;
+    /**
+     * 根据关键词搜索 Task（标题 + 描述）- 原始实现，保留兼容
+     * @deprecated 使用 searchTasksByKeywords 代替
+     */
+    searchTasks(query: string, limit?: number): Promise<Task[]>;
+}
+/**
+ * TagService 实现
+ */
+export declare class DefaultTagService implements TagService {
+    private store;
+    constructor(store: TaskStore);
+    createTag(name: string): Promise<TaskTag>;
+    getTag(id: number): Promise<TaskTag | undefined>;
+    getTagByName(name: string): Promise<TaskTag | undefined>;
+    listTags(options?: ListTagsOptions): Promise<TaskTag[]>;
+    searchTags(options: SearchTagsOptions): Promise<TaskTag[]>;
+    deleteTag(id: number): Promise<boolean>;
+    addTagsToTask(taskId: number, tagIds: number[]): Promise<void>;
+    removeTagsFromTask(taskId: number, tagIds: number[]): Promise<void>;
+    getTagsForTask(taskId: number): Promise<TaskTag[]>;
+    getTaskIdsByTags(tagNames: string[]): Promise<number[]>;
+    /**
+     * 根据关键词列表搜索 Task
+     * @deprecated 使用 findSimilarTasksByKeywords 代替
+     */
+    findSimilarTasks(taskId: number, limit?: number): Promise<Task[]>;
+    /**
+     * 根据关键词搜索 Task（单字符串）- 原始实现
+     * @deprecated 使用 searchTasksByKeywords 代替
+     */
+    searchTasks(query: string, limit?: number): Promise<Task[]>;
+    /**
+     * 根据关键词列表搜索 Task
+     * 检索范围：tags、description、goals、operations
+     */
+    searchTasksByKeywords(keywords: string[], options?: {
+        limit?: number;
+        excludeTaskId?: number;
+    }): Promise<Task[]>;
+    /**
+     * 根据关键词查找类似 Task
+     */
+    findSimilarTasksByKeywords(keywords: string[], options?: {
+        limit?: number;
+        excludeTaskId?: number;
+    }): Promise<Task[]>;
+    syncTagsToTask(taskId: number, tagNames: string[]): Promise<void>;
+}
+//# sourceMappingURL=tag-service.d.ts.map