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

package/dist/core/src/env/task/tag-service.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview TagService - Tag 池管理服务
+ *
+ * 提供 Tag 的 CRUD、Tag 与 Task 关联、类似任务检索能力
+ *
+ * 设计原则：
+ * - Tag 池模式：新 Tag 从池中选取，无合适则新增
+ * - 混合存储：Task.tags JSON 快速读取 + Tag 表高效检索
+ */
+import { createLogger } from "../log-trace/logger.js";
+const logger = createLogger("task:tag");
+// ========================================================================
+// TagService 实现
+// ========================================================================
+/**
+ * TagService 实现
+ */
+export class DefaultTagService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    // ========== Tag CRUD ==========
+    async createTag(name) {
+        const tag = await this.store.createTag(name);
+        logger.debug(`[TagService] Created tag: ${tag.name} (id=${tag.id})`);
+        return tag;
+    }
+    async getTag(id) {
+        return this.store.getTag(id);
+    }
+    async getTagByName(name) {
+        return this.store.getTagByName(name);
+    }
+    async listTags(options) {
+        return this.store.listTags(options);
+    }
+    async searchTags(options) {
+        return this.store.searchTags(options);
+    }
+    async deleteTag(id) {
+        const result = await this.store.deleteTag(id);
+        if (result) {
+            logger.debug(`[TagService] Deleted tag id=${id}`);
+        }
+        return result;
+    }
+    // ========== Tag 与 Task 关联 ==========
+    async addTagsToTask(taskId, tagIds) {
+        await this.store.addTagsToTask(taskId, tagIds);
+        logger.debug(`[TagService] Added ${tagIds.length} tags to task ${taskId}`);
+    }
+    async removeTagsFromTask(taskId, tagIds) {
+        await this.store.removeTagsFromTask(taskId, tagIds);
+        logger.debug(`[TagService] Removed ${tagIds.length} tags from task ${taskId}`);
+    }
+    async getTagsForTask(taskId) {
+        return this.store.getTagsForTask(taskId);
+    }
+    async getTaskIdsByTags(tagNames) {
+        return this.store.getTaskIdsByTags(tagNames);
+    }
+    // ========== 检索能力（核心改造）==========
+    /**
+     * 根据关键词列表搜索 Task
+     * @deprecated 使用 findSimilarTasksByKeywords 代替
+     */
+    async findSimilarTasks(taskId, limit = 5) {
+        return this.store.findSimilarTasks(taskId, limit);
+    }
+    /**
+     * 根据关键词搜索 Task（单字符串）- 原始实现
+     * @deprecated 使用 searchTasksByKeywords 代替
+     */
+    async searchTasks(query, limit = 20) {
+        return this.store.searchTasks(query, limit);
+    }
+    /**
+     * 根据关键词列表搜索 Task
+     * 检索范围：tags、description、goals、operations
+     */
+    async searchTasksByKeywords(keywords, options) {
+        return this.store.searchTasksByKeywords(keywords, options);
+    }
+    /**
+     * 根据关键词查找类似 Task
+     */
+    async findSimilarTasksByKeywords(keywords, options) {
+        return this.store.findSimilarTasksByKeywords(keywords, options);
+    }
+    // ========== 同步 ==========
+    async syncTagsToTask(taskId, tagNames) {
+        // 1. 查找或创建每个 Tag
+        const tagIds = [];
+        for (const name of tagNames) {
+            let tag = await this.store.getTagByName(name);
+            if (!tag) {
+                tag = await this.store.createTag(name);
+            }
+            tagIds.push(tag.id);
+        }
+        // 2. 获取当前 Task 的所有 Tags
+        const currentTags = await this.store.getTagsForTask(taskId);
+        const currentTagIds = new Set(currentTags.map(t => t.id));
+        const newTagIds = new Set(tagIds);
+        // 3. 计算需要添加和移除的 Tags
+        const toAdd = tagIds.filter(id => !currentTagIds.has(id));
+        const toRemove = currentTags
+            .filter(t => !newTagIds.has(t.id))
+            .map(t => t.id);
+        // 4. 执行同步
+        if (toRemove.length > 0) {
+            await this.store.removeTagsFromTask(taskId, toRemove);
+        }
+        if (toAdd.length > 0) {
+            await this.store.addTagsToTask(taskId, toAdd);
+        }
+        // 5. 更新 Task.tags JSON 字段
+        await this.store.updateTaskTags(taskId, tagNames);
+        logger.info(`[TagService] Synced tags for task ${taskId}: ${tagNames.join(", ")}`);
+    }
+}
+//# sourceMappingURL=tag-service.js.map

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

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview TagService Tests
+ */
+export {};
+//# sourceMappingURL=tag-service.test.d.ts.map

package/dist/core/src/env/task/tag-service.test.js

@@ -0,0 +1,157 @@
+/**
+ * @fileoverview TagService Tests
+ */
+import { describe, test, expect, beforeEach } from "vitest";
+import { DefaultTagService } from "./tag-service.js";
+import { SQLiteTaskStore } from "./storage/sqlite-task-store.js";
+describe("TagService", () => {
+    let store;
+    let tagService;
+    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");
+        });
+    });
+});
+//# sourceMappingURL=tag-service.test.js.map

package/dist/core/src/env/task/task-component.d.ts

@@ -0,0 +1,171 @@
+/**
+ * @fileoverview Task Component
+ *
+ * Component for managing task lifecycle including:
+ * - Task CRUD operations
+ * - Operation record management
+ * - Tool registration
+ */
+import { BaseComponent, type ComponentConfig } from "../component";
+import { type TaskConfig, type Task, type TaskOperation, type CreateTaskOptions, type UpdateTaskOptions, type ListTasksOptions, type CreateOperationOptions, type ListOperationsOptions } from "./types";
+import type { ConfigComponent } from "../../config/config-component";
+import { type TagService } from "./tag-service";
+import { TaskPlugin } from "./plugins";
+/**
+ * TaskComponent 配置选项（通过 options 传递）
+ *
+ * 配置加载顺序（优先级从低到高）：
+ * 1. File - 配置文件（通过 configPath 指定）
+ * 2. Env - 环境变量（通过 envPrefix 配置前缀）
+ * 3. Object - 直接传入的 config 对象（最高优先级）
+ */
+export interface TaskComponentOptions {
+    /** ConfigComponent 实例（必填） */
+    configComponent: ConfigComponent;
+    /** 配置文件相对路径（可选，基于 XDG_DATA_HOME） */
+    configPath?: string;
+    /** 环境变量前缀（可选，默认 "TASK"） */
+    envPrefix?: string;
+    /** 直接传入的配置对象（可选，优先级最高） */
+    config?: Partial<TaskConfig>;
+}
+export declare class TaskComponent extends BaseComponent {
+    name: string;
+    version: string;
+    private store;
+    private config?;
+    private toolComponent?;
+    private backgroundTaskManager?;
+    private configComponent?;
+    private tagService;
+    private plugins;
+    constructor();
+    /**
+     * Initialize the component
+     *
+     * 配置加载优先级（从高到低）：
+     * 1. Object - 直接传入的 config 对象
+     * 2. Env - 环境变量（通过 envPrefix 配置前缀）
+     * 3. File - 配置文件（通过 configPath 指定）
+     */
+    init(config?: ComponentConfig): Promise<void>;
+    /**
+     * 注册配置到 ConfigComponent
+     *
+     * 配置加载顺序（优先级从低到高）：
+     * 1. Defaults - 默认值（最低）
+     * 2. FileSource - 从配置文件加载
+     * 3. EnvSource - 从环境变量加载
+     * 4. config 对象 - 直接传入的配置（最高）
+     */
+    private registerConfig;
+    /**
+     * 根据配置初始化 store
+     */
+    private initStore;
+    /**
+     * 将配置对象展平为点号路径
+     */
+    private flattenConfig;
+    /**
+     * 注册配置热更新监听
+     */
+    private registerConfigWatcher;
+    /**
+     * 处理配置变更
+     */
+    protected onConfigChange(event: {
+        key: string;
+        oldValue?: unknown;
+        newValue?: unknown;
+    }): void;
+    /** 配置变更 watcher 清理函数 */
+    private configWatcher?;
+    /**
+     * Start the component - register tools
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the component
+     */
+    stop(): Promise<void>;
+    /**
+     * Register task tools to ToolComponent
+     */
+    private registerTools;
+    /**
+     * 执行 Hook
+     */
+    private executeHook;
+    /**
+     * Create a new task
+     */
+    createTask(options: CreateTaskOptions): Promise<Task>;
+    /**
+     * Get task by ID
+     */
+    getTask(id: number): Promise<Task | undefined>;
+    /**
+     * Get task with operations
+     */
+    getTaskWithOperations(id: number): Promise<{
+        task: Task;
+        operations: TaskOperation[];
+    } | undefined>;
+    /**
+     * Update task
+     */
+    updateTask(id: number, options: UpdateTaskOptions): Promise<Task | undefined>;
+    /**
+     * Delete task
+     */
+    deleteTask(id: number): Promise<boolean>;
+    /**
+     * List tasks
+     */
+    listTasks(options?: ListTasksOptions): Promise<Task[]>;
+    /**
+     * Complete task
+     */
+    completeTask(id: number, sessionId: string): Promise<Task | undefined>;
+    /**
+     * Create operation record
+     */
+    createOperation(options: CreateOperationOptions): Promise<TaskOperation>;
+    /**
+     * Get operation by ID
+     */
+    getOperation(id: number): Promise<TaskOperation | undefined>;
+    /**
+     * Update operation
+     */
+    updateOperation(id: number, updates: {
+        actionTitle?: string;
+        actionDescription?: string;
+    }): Promise<TaskOperation | undefined>;
+    /**
+     * Delete operation
+     */
+    deleteOperation(id: number): Promise<boolean>;
+    /**
+     * List operations for a task
+     */
+    listOperations(options: ListOperationsOptions): Promise<TaskOperation[]>;
+    /**
+     * 获取 TagService
+     */
+    getTagService(): TagService;
+    /**
+     * 注册 Plugin
+     */
+    registerPlugin(plugin: TaskPlugin): void;
+    /**
+     * 注销 Plugin
+     */
+    unregisterPlugin(name: string): boolean;
+    /**
+     * 获取所有注册的 Plugin
+     */
+    listPlugins(): TaskPlugin[];
+}
+//# sourceMappingURL=task-component.d.ts.map