@ai-setting/roy-agent-core 1.5.13-test → 1.5.15-test

package/dist/shared/@ai-setting/roy-agent-core-gwc4h96n.js

@@ -1,534 +0,0 @@
-import {
-  BackgroundTaskManager,
-  createDelegateTool,
-  createStopTool
-} from "./roy-agent-core-vf215qfv.js";
-import {
-  SQLiteTaskStore,
-  getDefaultTaskDbPath
-} from "./roy-agent-core-bvr1761x.js";
-import {
-  completeTaskTool,
-  createTaskTool,
-  deleteTaskTool,
-  getTaskTool,
-  listTasksTool,
-  updateTaskTool
-} from "./roy-agent-core-wa1kzqky.js";
-import {
-  createOperationTool,
-  deleteOperationTool,
-  getOperationTool,
-  listOperationsTool,
-  updateOperationTool
-} from "./roy-agent-core-t94ktchq.js";
-import {
-  TaskHookPoints
-} from "./roy-agent-core-92z6t4he.js";
-import {
-  TaskEntityEventTypes
-} from "./roy-agent-core-8gxth0eh.js";
-import {
-  envKeyToConfigKey
-} from "./roy-agent-core-qxhq8ven.js";
-import {
-  BaseComponent
-} from "./roy-agent-core-kkbwepqb.js";
-import {
-  globalHookManager
-} from "./roy-agent-core-gjq1yk68.js";
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-44hnfb02.js";
-
-// src/env/task/task-component.ts
-init_logger();
-
-// src/env/task/task-config-registration.ts
-var TASK_DEFAULTS = {
-  "task.storage.type": "sqlite",
-  "task.storage.dbPath": undefined
-};
-var TASK_CONFIG_REGISTRATION = {
-  name: "task",
-  sources: [
-    { type: "env", envPrefix: "TASK", priority: 20, watch: false }
-  ],
-  keys: [
-    { key: "task.storage.type", sources: ["env", "file"] },
-    { key: "task.storage.dbPath", sources: ["env", "file"] }
-  ]
-};
-
-// src/env/task/tag-service.ts
-init_logger();
-var logger = createLogger("task:tag");
-
-class DefaultTagService {
-  store;
-  constructor(store) {
-    this.store = store;
-  }
-  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;
-  }
-  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);
-  }
-  async findSimilarTasks(taskId, limit = 5) {
-    return this.store.findSimilarTasks(taskId, limit);
-  }
-  async searchTasks(query, limit = 20) {
-    return this.store.searchTasks(query, limit);
-  }
-  async searchTasksByKeywords(keywords, options) {
-    return this.store.searchTasksByKeywords(keywords, options);
-  }
-  async findSimilarTasksByKeywords(keywords, options) {
-    return this.store.findSimilarTasksByKeywords(keywords, options);
-  }
-  async syncTagsToTask(taskId, tagNames) {
-    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);
-    }
-    const currentTags = await this.store.getTagsForTask(taskId);
-    const currentTagIds = new Set(currentTags.map((t) => t.id));
-    const newTagIds = new Set(tagIds);
-    const toAdd = tagIds.filter((id) => !currentTagIds.has(id));
-    const toRemove = currentTags.filter((t) => !newTagIds.has(t.id)).map((t) => t.id);
-    if (toRemove.length > 0) {
-      await this.store.removeTagsFromTask(taskId, toRemove);
-    }
-    if (toAdd.length > 0) {
-      await this.store.addTagsToTask(taskId, toAdd);
-    }
-    await this.store.updateTaskTags(taskId, tagNames);
-    logger.info(`[TagService] Synced tags for task ${taskId}: ${tagNames.join(", ")}`);
-  }
-}
-
-// src/env/task/task-component.ts
-var logger2 = createLogger("task");
-
-class TaskComponent extends BaseComponent {
-  name = "task";
-  version = "1.0.0";
-  store;
-  config;
-  toolComponent;
-  backgroundTaskManager;
-  configComponent;
-  tagService;
-  plugins = new Map;
-  publishEvent(type, payload, sessionId) {
-    if (this.env?.pushEnvEvent) {
-      this.env.pushEnvEvent({
-        type,
-        payload,
-        metadata: {
-          source: "task.component",
-          trigger_session_id: sessionId
-        }
-      });
-      logger2.info(`[TaskComponent] Event published: ${type}`);
-    }
-  }
-  constructor() {
-    super();
-  }
-  async init(config) {
-    await super.init(config);
-    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");
-    logger2.info("[TaskComponent] Initialized");
-  }
-  async registerConfig(options) {
-    const configComponent = this.configComponent;
-    if (!configComponent)
-      return;
-    const { configPath, envPrefix, config } = options;
-    const prefix = envPrefix ?? "TASK";
-    configComponent.registerComponent(TASK_CONFIG_REGISTRATION);
-    if (configPath) {
-      configComponent.registerSource({
-        type: "file",
-        relativePath: configPath,
-        optional: true,
-        watch: false
-      });
-    }
-    configComponent.registerSource({
-      type: "env",
-      envPrefix: prefix,
-      priority: 20,
-      watch: false
-    });
-    await configComponent.load("task");
-    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);
-      }
-    }
-    for (const [key, value] of Object.entries(TASK_DEFAULTS)) {
-      if (configComponent.get(key) === undefined) {
-        await configComponent.set(key, value);
-      }
-    }
-    if (configComponent.get("task.storage.dbPath") === undefined) {
-      await configComponent.set("task.storage.dbPath", getDefaultTaskDbPath());
-    }
-    if (config) {
-      const flatConfig = this.flattenConfig(config);
-      for (const [key, value] of Object.entries(flatConfig)) {
-        await configComponent.set(key, value);
-      }
-    }
-    this.registerConfigWatcher(configComponent);
-    await this.initStore();
-    this.tagService = new DefaultTagService(this.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);
-      logger2.info(`[TaskComponent] Using SQLite storage: ${dbPath || "default path"}`);
-    } else {
-      this.store = new SQLiteTaskStore;
-      logger2.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) {
-    logger2.info(`[TaskComponent] Config changed: ${event.key}`, {
-      oldValue: event.oldValue,
-      newValue: event.newValue
-    });
-    if (event.key === "task.storage.type" || event.key === "task.storage.dbPath") {
-      this.initStore();
-    }
-  }
-  configWatcher;
-  async start() {
-    await super.start();
-    this.backgroundTaskManager = new BackgroundTaskManager(this.env);
-    this.toolComponent = this.env?.getComponent("tool");
-    if (this.toolComponent) {
-      await this.registerTools();
-    } else {
-      logger2.warn("[TaskComponent] ToolComponent not found, skipping tool registration");
-    }
-  }
-  async stop() {
-    if (this.configWatcher) {
-      this.configWatcher();
-      this.configWatcher = undefined;
-    }
-    if (this.backgroundTaskManager) {
-      this.backgroundTaskManager.dispose();
-    }
-    if (this.store) {
-      await this.store.close();
-    }
-    await super.stop();
-  }
-  async registerTools() {
-    if (!this.toolComponent)
-      return;
-    const taskToolsList = [
-      createTaskTool(this),
-      getTaskTool(this),
-      listTasksTool(this),
-      updateTaskTool(this),
-      deleteTaskTool(this),
-      completeTaskTool(this)
-    ];
-    const operationToolsList = [
-      createOperationTool(this),
-      getOperationTool(this),
-      listOperationsTool(this),
-      updateOperationTool(this),
-      deleteOperationTool(this)
-    ];
-    const delegateTools = [
-      createDelegateTool(this),
-      createStopTool(this.backgroundTaskManager)
-    ];
-    for (const tool of [...taskToolsList, ...operationToolsList, ...delegateTools]) {
-      this.toolComponent.register(tool);
-      logger2.info(`[TaskComponent] Registered tool: ${tool.name}`);
-    }
-  }
-  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);
-  }
-  async createTask(options) {
-    const sessionId = options.sessionId;
-    const createCtx = {
-      options: { ...options },
-      sessionId,
-      tagService: this.tagService
-    };
-    await this.executeHook(TaskHookPoints.BEFORE_CREATE, createCtx);
-    const task = await this.store.createTask(createCtx.options);
-    await this.store.createOperation({
-      taskId: task.id,
-      sessionId,
-      actionType: "create",
-      actionTitle: `Task created: ${task.title}`,
-      actionDescription: task.description || ""
-    });
-    const resultCtx = {
-      task,
-      sessionId,
-      tagService: this.tagService
-    };
-    await this.executeHook(TaskHookPoints.AFTER_CREATE, resultCtx);
-    this.publishEvent(TaskEntityEventTypes.CREATED, { task, sessionId }, sessionId);
-    logger2.info(`[TaskComponent] Task created: ${task.id} - ${task.title}`);
-    return task;
-  }
-  async getTask(id) {
-    return this.store.getTask(id);
-  }
-  async getTaskWithOperations(id) {
-    const task = await this.store.getTask(id);
-    if (!task)
-      return;
-    const operations = await this.store.listOperations({ taskId: id });
-    return { task, operations };
-  }
-  async updateTask(id, options) {
-    const updateCtx = {
-      id,
-      options: { ...options },
-      tagService: this.tagService
-    };
-    await this.executeHook(TaskHookPoints.BEFORE_UPDATE, updateCtx);
-    const task = await this.store.updateTask(id, updateCtx.options);
-    if (task) {
-      const resultCtx = {
-        task,
-        changes: options,
-        tagService: this.tagService
-      };
-      await this.executeHook(TaskHookPoints.AFTER_UPDATE, resultCtx);
-      this.publishEvent(TaskEntityEventTypes.UPDATED, { task, changes: options, sessionId: "" }, "");
-      logger2.info(`[TaskComponent] Task updated: ${id}`);
-    }
-    return task;
-  }
-  async deleteTask(id) {
-    const deleteCtx = { id };
-    await this.executeHook(TaskHookPoints.BEFORE_DELETE, deleteCtx);
-    const result = await this.store.deleteTask(id);
-    const resultCtx = { id, deleted: result };
-    await this.executeHook(TaskHookPoints.AFTER_DELETE, resultCtx);
-    if (result) {
-      this.publishEvent(TaskEntityEventTypes.DELETED, { taskId: id, sessionId: "" }, "");
-      logger2.info(`[TaskComponent] Task deleted: ${id}`);
-    }
-    return result;
-  }
-  async listTasks(options) {
-    return this.store.listTasks(options);
-  }
-  async completeTask(id, sessionId) {
-    const task = await this.store.updateTask(id, {
-      status: "completed",
-      progress: 100
-    });
-    if (task) {
-      await this.createOperation({
-        taskId: id,
-        sessionId,
-        actionType: "completed",
-        actionTitle: "Task completed"
-      });
-      this.publishEvent(TaskEntityEventTypes.COMPLETED, { task, sessionId }, sessionId);
-      logger2.info(`[TaskComponent] Task completed: ${id}`);
-    }
-    return task;
-  }
-  async createOperation(options) {
-    const createCtx = {
-      options: { ...options }
-    };
-    await this.executeHook(TaskHookPoints.OPERATION_BEFORE_CREATE, createCtx);
-    const op = await this.store.createOperation(createCtx.options);
-    const resultCtx = { operation: op };
-    await this.executeHook(TaskHookPoints.OPERATION_AFTER_CREATE, resultCtx);
-    this.publishEvent(TaskEntityEventTypes.OPERATION_ADDED, { operation: op, taskId: op.taskId }, op.sessionId);
-    logger2.info(`[TaskComponent] Operation created: ${op.id} for task ${op.taskId}`);
-    return op;
-  }
-  async getOperation(id) {
-    return this.store.getOperation(id);
-  }
-  async updateOperation(id, updates) {
-    return this.store.updateOperation(id, updates);
-  }
-  async deleteOperation(id) {
-    return this.store.deleteOperation(id);
-  }
-  async listOperations(options) {
-    return this.store.listOperations(options);
-  }
-  getTagService() {
-    return this.tagService;
-  }
-  registerPlugin(plugin) {
-    this.plugins.set(plugin.name, plugin);
-    const llmComponent = this.env?.getComponent("llm");
-    plugin.setComponents?.(llmComponent, this);
-    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) {
-          logger2.warn(`Failed to auto-register agents for plugin ${plugin.name}: ${err}`);
-        }
-      }
-    }
-    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;
-      globalHookManager.register(hook.point, {
-        name: hookName,
-        priority,
-        execute: async (ctx) => {
-          const pluginCtx = {
-            component: ctx.component,
-            data: ctx.data,
-            metadata: ctx.metadata,
-            phase: ctx.phase,
-            hookPoint: hook.point
-          };
-          await pluginRef.execute(pluginCtx);
-        }
-      });
-    }
-    logger2.info(`[TaskComponent] Registered plugin: ${plugin.name}`, {
-      hooks: plugin.hooks.map((h) => h.point)
-    });
-  }
-  unregisterPlugin(name) {
-    const plugin = this.plugins.get(name);
-    if (!plugin)
-      return false;
-    for (const hook of plugin.hooks) {
-      globalHookManager.unregister(hook.point, `${this.name}:${name}`);
-    }
-    this.plugins.delete(name);
-    logger2.info(`[TaskComponent] Unregistered plugin: ${name}`);
-    return true;
-  }
-  listPlugins() {
-    return Array.from(this.plugins.values());
-  }
-}
-// src/env/task/types.ts
-import { z } from "zod";
-var TaskStatusEnum = z.enum(["todo", "active", "completed", "paused", "cancelled"]);
-var TaskPriorityEnum = z.enum(["low", "medium", "high"]);
-var ActionTypeEnum = z.enum([
-  "create",
-  "progress",
-  "milestone",
-  "problem",
-  "solution",
-  "decision",
-  "review",
-  "completed",
-  "workflow_extracted"
-]);
-var TaskConfigSchema = z.object({
-  storage: z.object({
-    type: z.enum(["memory", "sqlite"]).default("sqlite"),
-    dbPath: z.string().optional()
-  }).default({})
-}).default({});
-export { TaskComponent, TaskStatusEnum, TaskPriorityEnum, ActionTypeEnum, TaskConfigSchema };