@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

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

@@ -1,5 +0,0 @@
-/**
- * @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

@@ -1,235 +0,0 @@
-/**
- * @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

@@ -1,5 +0,0 @@
-/**
- * @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

@@ -1,236 +0,0 @@
-/**
- * @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

@@ -1,139 +0,0 @@
-/**
- * @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