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

package/dist/core/src/env/task/task-component.js

@@ -1,519 +0,0 @@
-/**
- * @fileoverview Task Component
- *
- * Component for managing task lifecycle including:
- * - Task CRUD operations
- * - Operation record management
- * - Tool registration
- */
-import { BaseComponent } from "../component.js";
-import { SQLiteTaskStore, getDefaultTaskDbPath } from "./storage/index.js";
-import { createLogger } from "../log-trace/logger.js";
-import * as taskTools from "./tools/index.js";
-import * as operationTools from "./tools/operation/index.js";
-import { createDelegateTool, createStopTool, BackgroundTaskManager } from "./delegate/index.js";
-import { TASK_CONFIG_REGISTRATION, TASK_DEFAULTS } from "./task-config-registration.js";
-import { envKeyToConfigKey } from "../../config/env-key.js";
-// Hook 机制
-import { globalHookManager } from "../hook/global-hook-manager.js";
-import { TaskHookPoints } from "./hooks/index.js";
-// Tag 服务
-import { DefaultTagService } from "./tag-service.js";
-const logger = createLogger("task");
-export class TaskComponent extends BaseComponent {
-    name = "task";
-    version = "1.0.0";
-    store;
-    config;
-    toolComponent;
-    backgroundTaskManager;
-    configComponent;
-    tagService;
-    plugins = new Map();
-    constructor() {
-        super();
-    }
-    /**
-     * Initialize the component
-     *
-     * 配置加载优先级（从高到低）：
-     * 1. Object - 直接传入的 config 对象
-     * 2. Env - 环境变量（通过 envPrefix 配置前缀）
-     * 3. File - 配置文件（通过 configPath 指定）
-     */
-    async init(config) {
-        // 调用基类 init，注入 env
-        await super.init(config);
-        // 从 options 获取 ConfigComponent
-        const options = config?.options;
-        if (!options?.configComponent) {
-            throw new Error("ConfigComponent is required for TaskComponent initialization");
-        }
-        this.configComponent = options.configComponent;
-        await this.registerConfig(options);
-        this.setStatus("running");
-        logger.info("[TaskComponent] Initialized");
-    }
-    /**
-     * 注册配置到 ConfigComponent
-     *
-     * 配置加载顺序（优先级从低到高）：
-     * 1. Defaults - 默认值（最低）
-     * 2. FileSource - 从配置文件加载
-     * 3. EnvSource - 从环境变量加载
-     * 4. config 对象 - 直接传入的配置（最高）
-     */
-    async registerConfig(options) {
-        const configComponent = this.configComponent;
-        if (!configComponent)
-            return;
-        const { configPath, envPrefix, config } = options;
-        const prefix = envPrefix ?? "TASK";
-        // 1. 使用 registerComponent 注册配置结构（keys 和 sources，不含 defaults）
-        configComponent.registerComponent(TASK_CONFIG_REGISTRATION);
-        // 2. 注册 FileSource（如果提供了 configPath）
-        if (configPath) {
-            configComponent.registerSource({
-                type: "file",
-                relativePath: configPath,
-                optional: true,
-                watch: false
-            });
-        }
-        // 3. 注册 EnvSource
-        configComponent.registerSource({
-            type: "env",
-            envPrefix: prefix,
-            priority: 20,
-            watch: false
-        });
-        // 4. 从 sources 加载配置（FileSource 和 EnvSource）
-        await configComponent.load("task");
-        // 5. 后备方案：直接读取环境变量（确保所有环境变量都被处理）
-        for (const envKey of Object.keys(process.env)) {
-            const configKey = envKeyToConfigKey(envKey, prefix, "task");
-            if (!configKey)
-                continue;
-            const value = process.env[envKey];
-            if (value !== undefined) {
-                await configComponent.set(configKey, value);
-            }
-        }
-        // 6. 设置默认值（只有当配置不存在时）
-        for (const [key, value] of Object.entries(TASK_DEFAULTS)) {
-            if (configComponent.get(key) === undefined) {
-                await configComponent.set(key, value);
-            }
-        }
-        // 6.5 特殊处理 dbPath 动态默认值（只有当配置不存在时）
-        if (configComponent.get("task.storage.dbPath") === undefined) {
-            await configComponent.set("task.storage.dbPath", getDefaultTaskDbPath());
-        }
-        // 7. 直接配置对象（最高优先级）
-        if (config) {
-            const flatConfig = this.flattenConfig(config);
-            for (const [key, value] of Object.entries(flatConfig)) {
-                await configComponent.set(key, value);
-            }
-        }
-        // 8. 注册配置热更新监听
-        this.registerConfigWatcher(configComponent);
-        // 9. 解析最终配置并初始化 store
-        await this.initStore();
-        // 10. 初始化 TagService
-        this.tagService = new DefaultTagService(this.store);
-    }
-    /**
-     * 根据配置初始化 store
-     */
-    async initStore() {
-        const configComponent = this.configComponent;
-        if (!configComponent)
-            return;
-        const storageType = configComponent.get("task.storage.type") ?? "sqlite";
-        const dbPath = configComponent.get("task.storage.dbPath");
-        if (storageType === "sqlite") {
-            this.store = new SQLiteTaskStore(dbPath);
-            logger.info(`[TaskComponent] Using SQLite storage: ${dbPath || "default path"}`);
-        }
-        else {
-            this.store = new SQLiteTaskStore();
-            logger.info("[TaskComponent] Using SQLite storage (default)");
-        }
-    }
-    /**
-     * 将配置对象展平为点号路径
-     */
-    flattenConfig(obj, prefix = "task") {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-            const fullKey = `${prefix}.${key}`;
-            if (value && typeof value === "object" && !Array.isArray(value)) {
-                Object.assign(result, this.flattenConfig(value, fullKey));
-            }
-            else {
-                result[fullKey] = value;
-            }
-        }
-        return result;
-    }
-    /**
-     * 注册配置热更新监听
-     */
-    registerConfigWatcher(configComponent) {
-        if (typeof configComponent.watch !== "function") {
-            return;
-        }
-        this.configWatcher = configComponent.watch("task.*", (event) => {
-            this.onConfigChange(event);
-        });
-    }
-    /**
-     * 处理配置变更
-     */
-    onConfigChange(event) {
-        logger.info(`[TaskComponent] Config changed: ${event.key}`, {
-            oldValue: event.oldValue,
-            newValue: event.newValue
-        });
-        // 如果 storage 配置变更，需要重新初始化 store
-        if (event.key === "task.storage.type" || event.key === "task.storage.dbPath") {
-            this.initStore();
-        }
-    }
-    /** 配置变更 watcher 清理函数 */
-    configWatcher;
-    /**
-     * Start the component - register tools
-     */
-    async start() {
-        await super.start();
-        // Create BackgroundTaskManager
-        this.backgroundTaskManager = new BackgroundTaskManager(this.env);
-        // Get ToolComponent and register tools
-        this.toolComponent = this.env?.getComponent("tool");
-        if (this.toolComponent) {
-            await this.registerTools();
-        }
-        else {
-            logger.warn("[TaskComponent] ToolComponent not found, skipping tool registration");
-        }
-    }
-    /**
-     * Stop the component
-     */
-    async stop() {
-        // 清理配置 watcher
-        if (this.configWatcher) {
-            this.configWatcher();
-            this.configWatcher = undefined;
-        }
-        // Dispose BackgroundTaskManager to clean up timers and prevent process hanging
-        if (this.backgroundTaskManager) {
-            this.backgroundTaskManager.dispose();
-        }
-        if (this.store) {
-            await this.store.close();
-        }
-        await super.stop();
-    }
-    // ========================================================================
-    // Tool Registration
-    // ========================================================================
-    /**
-     * Register task tools to ToolComponent
-     */
-    async registerTools() {
-        if (!this.toolComponent)
-            return;
-        // Task tools
-        const taskToolsList = [
-            taskTools.createTaskTool(this),
-            taskTools.getTaskTool(this),
-            taskTools.listTasksTool(this),
-            taskTools.updateTaskTool(this),
-            taskTools.deleteTaskTool(this),
-            taskTools.completeTaskTool(this),
-        ];
-        // Operation tools
-        const operationToolsList = [
-            operationTools.createOperationTool(this),
-            operationTools.getOperationTool(this),
-            operationTools.listOperationsTool(this),
-            operationTools.updateOperationTool(this),
-            operationTools.deleteOperationTool(this),
-        ];
-        // Delegate tools (with background task manager)
-        const delegateTools = [
-            createDelegateTool(this),
-            createStopTool(this.backgroundTaskManager),
-        ];
-        // Register all tools
-        for (const tool of [...taskToolsList, ...operationToolsList, ...delegateTools]) {
-            this.toolComponent.register(tool);
-            logger.info(`[TaskComponent] Registered tool: ${tool.name}`);
-        }
-    }
-    // ========================================================================
-    // Hook 执行
-    // ========================================================================
-    /**
-     * 执行 Hook
-     */
-    async executeHook(hookPoint, data, metadata = {}) {
-        const ctx = {
-            component: { name: this.name, version: this.version },
-            data,
-            metadata,
-            phase: hookPoint.includes("before") ? "before" : "after",
-            hookPoint,
-        };
-        await globalHookManager.execute(hookPoint, ctx, metadata);
-    }
-    // ========================================================================
-    // Task CRUD
-    // ========================================================================
-    /**
-     * Create a new task
-     */
-    async createTask(options) {
-        const sessionId = options.sessionId;
-        // 1. beforeCreate Hook
-        const createCtx = {
-            options: { ...options },
-            sessionId,
-            tagService: this.tagService,
-        };
-        await this.executeHook(TaskHookPoints.BEFORE_CREATE, createCtx);
-        // 2. 实际创建
-        const task = await this.store.createTask(createCtx.options);
-        // 3. Auto-create operation record for task creation
-        await this.store.createOperation({
-            taskId: task.id,
-            sessionId,
-            actionType: "create",
-            actionTitle: `Task created: ${task.title}`,
-            actionDescription: task.description || "",
-        });
-        // 4. afterCreate Hook
-        const resultCtx = {
-            task,
-            sessionId,
-            tagService: this.tagService,
-        };
-        await this.executeHook(TaskHookPoints.AFTER_CREATE, resultCtx);
-        logger.info(`[TaskComponent] Task created: ${task.id} - ${task.title}`);
-        return task;
-    }
-    /**
-     * Get task by ID
-     */
-    async getTask(id) {
-        return this.store.getTask(id);
-    }
-    /**
-     * Get task with operations
-     */
-    async getTaskWithOperations(id) {
-        const task = await this.store.getTask(id);
-        if (!task)
-            return undefined;
-        const operations = await this.store.listOperations({ taskId: id });
-        return { task, operations };
-    }
-    /**
-     * Update task
-     */
-    async updateTask(id, options) {
-        // 1. beforeUpdate Hook
-        const updateCtx = {
-            id,
-            options: { ...options },
-            tagService: this.tagService,
-        };
-        await this.executeHook(TaskHookPoints.BEFORE_UPDATE, updateCtx);
-        // 2. 实际更新
-        const task = await this.store.updateTask(id, updateCtx.options);
-        if (task) {
-            // 3. afterUpdate Hook
-            const resultCtx = {
-                task,
-                changes: options,
-                tagService: this.tagService,
-            };
-            await this.executeHook(TaskHookPoints.AFTER_UPDATE, resultCtx);
-            logger.info(`[TaskComponent] Task updated: ${id}`);
-        }
-        return task;
-    }
-    /**
-     * Delete task
-     */
-    async deleteTask(id) {
-        // 1. beforeDelete Hook
-        const deleteCtx = { id };
-        await this.executeHook(TaskHookPoints.BEFORE_DELETE, deleteCtx);
-        // 2. 实际删除
-        const result = await this.store.deleteTask(id);
-        // 3. afterDelete Hook
-        const resultCtx = { id, deleted: result };
-        await this.executeHook(TaskHookPoints.AFTER_DELETE, resultCtx);
-        if (result) {
-            logger.info(`[TaskComponent] Task deleted: ${id}`);
-        }
-        return result;
-    }
-    /**
-     * List tasks
-     */
-    async listTasks(options) {
-        return this.store.listTasks(options);
-    }
-    /**
-     * Complete task
-     */
-    async completeTask(id, sessionId) {
-        const task = await this.store.updateTask(id, {
-            status: "completed",
-            progress: 100,
-        });
-        if (task) {
-            // 调用 this.createOperation 以触发 OPERATION_AFTER_CREATE hook
-            await this.createOperation({
-                taskId: id,
-                sessionId,
-                actionType: "completed",
-                actionTitle: "Task completed",
-            });
-            logger.info(`[TaskComponent] Task completed: ${id}`);
-        }
-        return task;
-    }
-    // ========================================================================
-    // Operation CRUD
-    // ========================================================================
-    /**
-     * Create operation record
-     */
-    async createOperation(options) {
-        // 1. beforeCreate Hook
-        const createCtx = {
-            options: { ...options },
-        };
-        await this.executeHook(TaskHookPoints.OPERATION_BEFORE_CREATE, createCtx);
-        // 2. 实际创建
-        const op = await this.store.createOperation(createCtx.options);
-        // 3. afterCreate Hook
-        const resultCtx = { operation: op };
-        await this.executeHook(TaskHookPoints.OPERATION_AFTER_CREATE, resultCtx);
-        logger.info(`[TaskComponent] Operation created: ${op.id} for task ${op.taskId}`);
-        return op;
-    }
-    /**
-     * Get operation by ID
-     */
-    async getOperation(id) {
-        return this.store.getOperation(id);
-    }
-    /**
-     * Update operation
-     */
-    async updateOperation(id, updates) {
-        return this.store.updateOperation(id, updates);
-    }
-    /**
-     * Delete operation
-     */
-    async deleteOperation(id) {
-        return this.store.deleteOperation(id);
-    }
-    /**
-     * List operations for a task
-     */
-    async listOperations(options) {
-        return this.store.listOperations(options);
-    }
-    // ========================================================================
-    // Plugin Management
-    // ========================================================================
-    /**
-     * 获取 TagService
-     */
-    getTagService() {
-        return this.tagService;
-    }
-    /**
-     * 注册 Plugin
-     */
-    registerPlugin(plugin) {
-        this.plugins.set(plugin.name, plugin);
-        // 注入组件引用
-        const llmComponent = this.env?.getComponent("llm");
-        plugin.setComponents?.(llmComponent, this);
-        // === 自动注册依赖的 Agents ===
-        const getRequiredAgents = plugin.constructor.getRequiredAgents;
-        if (typeof getRequiredAgents === 'function') {
-            const agentComponent = this.env?.getComponent("agent");
-            if (agentComponent) {
-                try {
-                    const agents = getRequiredAgents();
-                    for (const agentConfig of agents) {
-                        agentComponent.registerAgent(agentConfig.name, agentConfig);
-                    }
-                }
-                catch (err) {
-                    logger.warn(`Failed to auto-register agents for plugin ${plugin.name}: ${err}`);
-                }
-            }
-        }
-        // === 自动注册结束 ===
-        // 注册 Hook 到 globalHookManager
-        for (const hook of plugin.hooks) {
-            const pluginConfig = plugin.config;
-            const priority = hook.priority ?? pluginConfig?.priority ?? 0;
-            const hookName = `${this.name}:${plugin.name}:${hook.point}`;
-            const pluginRef = plugin; // Capture plugin reference
-            globalHookManager.register(hook.point, {
-                name: hookName,
-                priority,
-                execute: async (ctx) => {
-                    // 直接传递 ctx.data（这是 Component 传入的 TaskCreateContext 等）
-                    // 同时注入 hookPoint 和 component 信息
-                    const pluginCtx = {
-                        component: ctx.component,
-                        data: ctx.data, // 直接传递 Component 的数据对象
-                        metadata: ctx.metadata,
-                        phase: ctx.phase,
-                        hookPoint: hook.point,
-                    };
-                    await pluginRef.execute(pluginCtx);
-                },
-            });
-        }
-        logger.info(`[TaskComponent] Registered plugin: ${plugin.name}`, {
-            hooks: plugin.hooks.map(h => h.point)
-        });
-    }
-    /**
-     * 注销 Plugin
-     */
-    unregisterPlugin(name) {
-        const plugin = this.plugins.get(name);
-        if (!plugin)
-            return false;
-        // 从 globalHookManager 移除
-        for (const hook of plugin.hooks) {
-            globalHookManager.unregister(hook.point, `${this.name}:${name}`);
-        }
-        this.plugins.delete(name);
-        logger.info(`[TaskComponent] Unregistered plugin: ${name}`);
-        return true;
-    }
-    /**
-     * 获取所有注册的 Plugin
-     */
-    listPlugins() {
-        return Array.from(this.plugins.values());
-    }
-}
-//# sourceMappingURL=task-component.js.map

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

@@ -1,5 +0,0 @@
-/**
- * @fileoverview TaskComponent Tests
- */
-export {};
-//# sourceMappingURL=task-component.test.d.ts.map

package/dist/core/src/env/task/task-component.test.js

@@ -1,163 +0,0 @@
-/**
- * @fileoverview TaskComponent Tests
- */
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { TaskComponent } from "./task-component.js";
-import { ConfigComponent } from "../../config/config-component.js";
-import { tmpdir } from "os";
-import { join } from "path";
-describe("TaskComponent", () => {
-    let taskComponent;
-    let configComponent;
-    beforeEach(async () => {
-        configComponent = new ConfigComponent();
-        taskComponent = new TaskComponent();
-        await taskComponent.init({
-            options: {
-                configComponent,
-                config: {
-                    storage: {
-                        type: "sqlite",
-                        dbPath: join(tmpdir(), `task-component-test-${Date.now()}.db`),
-                    },
-                },
-            },
-        });
-    });
-    afterEach(async () => {
-        await taskComponent.stop();
-    });
-    describe("createTask", () => {
-        it("should create a task", async () => {
-            const task = await taskComponent.createTask({
-                title: "Test Task",
-                sessionId: "sess_123",
-            });
-            expect(task.id).toBeGreaterThan(0);
-            expect(task.title).toBe("Test Task");
-            expect(task.status).toBe("todo");
-        });
-        it("should auto-create operation record", async () => {
-            const task = await taskComponent.createTask({
-                title: "Test Task",
-                sessionId: "sess_123",
-            });
-            const ops = await taskComponent.listOperations({ taskId: task.id });
-            expect(ops.length).toBe(1);
-            expect(ops[0].actionType).toBe("create");
-            expect(ops[0].sessionId).toBe("sess_123");
-        });
-    });
-    describe("getTask", () => {
-        it("should get task by id", async () => {
-            const created = await taskComponent.createTask({
-                title: "Test Task",
-                sessionId: "sess_123",
-            });
-            const task = await taskComponent.getTask(created.id);
-            expect(task?.title).toBe("Test Task");
-        });
-        it("should return undefined for non-existent task", async () => {
-            const task = await taskComponent.getTask(99999);
-            expect(task).toBeUndefined();
-        });
-    });
-    describe("updateTask", () => {
-        it("should update task", async () => {
-            const task = await taskComponent.createTask({
-                title: "Test Task",
-                sessionId: "sess_123",
-            });
-            const updated = await taskComponent.updateTask(task.id, {
-                status: "active",
-                progress: 50,
-                current_status: "正在实现功能",
-            });
-            expect(updated?.status).toBe("active");
-            expect(updated?.progress).toBe(50);
-            expect(updated?.current_status).toBe("正在实现功能");
-        });
-    });
-    describe("completeTask", () => {
-        it("should complete task with operation record", async () => {
-            const task = await taskComponent.createTask({
-                title: "Test Task",
-                sessionId: "sess_1",
-            });
-            await taskComponent.updateTask(task.id, { status: "active" });
-            const completed = await taskComponent.completeTask(task.id, "sess_2");
-            expect(completed?.status).toBe("completed");
-            expect(completed?.progress).toBe(100);
-            // Check operation record
-            const ops = await taskComponent.listOperations({ taskId: task.id });
-            const completedOp = ops.find(op => op.actionType === "completed");
-            expect(completedOp?.sessionId).toBe("sess_2");
-        });
-    });
-    describe("listTasks", () => {
-        it("should list tasks", async () => {
-            await taskComponent.createTask({ title: "Task 1", sessionId: "sess_1" });
-            await taskComponent.createTask({ title: "Task 2", sessionId: "sess_1" });
-            const tasks = await taskComponent.listTasks();
-            expect(tasks.length).toBe(2);
-        });
-        it("should filter by status", async () => {
-            const task1 = await taskComponent.createTask({ title: "Task 1", sessionId: "sess_1" });
-            await taskComponent.createTask({ title: "Task 2", sessionId: "sess_1" });
-            await taskComponent.updateTask(task1.id, { status: "active" });
-            const activeTasks = await taskComponent.listTasks({ status: "active" });
-            expect(activeTasks.length).toBe(1);
-        });
-    });
-    describe("cross-session operations", () => {
-        it("should track operations from different sessions", async () => {
-            const task = await taskComponent.createTask({
-                title: "Cross-Session Task",
-                sessionId: "sess_1",
-            });
-            await taskComponent.createOperation({
-                taskId: task.id,
-                sessionId: "sess_2",
-                actionType: "progress",
-                actionTitle: "Started working",
-            });
-            await taskComponent.createOperation({
-                taskId: task.id,
-                sessionId: "sess_2",
-                actionType: "progress",
-                actionTitle: "Made progress in session 2",
-            });
-            await taskComponent.createOperation({
-                taskId: task.id,
-                sessionId: "sess_3",
-                actionType: "milestone",
-                actionTitle: "Reached milestone in session 3",
-            });
-            const ops = await taskComponent.listOperations({ taskId: task.id });
-            expect(ops.length).toBe(4); // 1 create + 1 progress update + 2 manual
-            // Check session distribution
-            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);
-        });
-    });
-    describe("getTaskWithOperations", () => {
-        it("should return task with all operations", async () => {
-            const task = await taskComponent.createTask({
-                title: "Task with Ops",
-                sessionId: "sess_1",
-            });
-            await taskComponent.createOperation({
-                taskId: task.id,
-                sessionId: "sess_2",
-                actionType: "progress",
-                actionTitle: "Made progress",
-            });
-            const result = await taskComponent.getTaskWithOperations(task.id);
-            expect(result?.task.title).toBe("Task with Ops");
-            expect(result?.operations.length).toBe(2);
-        });
-    });
-});
-//# sourceMappingURL=task-component.test.js.map