@ai-setting/roy-agent-core 1.4.13 → 1.4.14

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

@@ -0,0 +1,513 @@
+import {
+  SQLiteTaskStore,
+  getDefaultTaskDbPath
+} from "./roy-agent-core-8wzz66qe.js";
+import {
+  completeTaskTool,
+  createTaskTool,
+  deleteTaskTool,
+  getTaskTool,
+  listTasksTool,
+  updateTaskTool
+} from "./roy-agent-core-12x57kf1.js";
+import {
+  createOperationTool,
+  deleteOperationTool,
+  getOperationTool,
+  listOperationsTool,
+  updateOperationTool
+} from "./roy-agent-core-gy0wp5h7.js";
+import {
+  BackgroundTaskManager,
+  createDelegateTool,
+  createStopTool
+} from "./roy-agent-core-t22nqt4d.js";
+import {
+  TaskHookPoints
+} from "./roy-agent-core-pzk1syce.js";
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-jv3b7v9w.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-m2x48hw6.js";
+import {
+  globalHookManager
+} from "./roy-agent-core-w75rafhy.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+
+// packages/core/src/env/task/task-component.ts
+init_logger();
+
+// packages/core/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"] }
+  ]
+};
+
+// packages/core/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(", ")}`);
+  }
+}
+
+// packages/core/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;
+  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);
+    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);
+      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) {
+      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"
+      });
+      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);
+    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());
+  }
+}
+// packages/core/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 };

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

@@ -0,0 +1,60 @@
+// packages/core/src/env/skill/types.ts
+import { z } from "zod";
+var SkillToolSchema = z.object({
+  skill: z.string().describe("Skill name to load")
+});
+
+// packages/core/src/env/skill/tool/skill-tool.ts
+function buildSkillDescription(items) {
+  const lines = [
+    "Load a skill by name. Available skills:",
+    "",
+    "## Available Skills",
+    ""
+  ];
+  if (items.length === 0) {
+    lines.push("No skills available.");
+  } else {
+    for (const item of items) {
+      lines.push(`- **${item.name}**: "${item.description}"`);
+    }
+  }
+  lines.push("");
+  lines.push("Use the 'skill' parameter to specify which skill to load.");
+  return lines.join(`
+`);
+}
+function createSkillTool(getSkillList, getSkill) {
+  return {
+    name: "skill",
+    description: buildSkillDescription(getSkillList()),
+    parameters: SkillToolSchema,
+    execute: async (args, ctx) => {
+      const params = SkillToolSchema.parse(args);
+      try {
+        const entry = getSkill(params.skill);
+        if (!entry) {
+          return {
+            success: false,
+            output: "",
+            error: `Skill not found: ${params.skill}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        return {
+          success: true,
+          output: entry.content,
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+export { SkillToolSchema, buildSkillDescription, createSkillTool };

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

@@ -0,0 +1,97 @@
+import {
+  createHook
+} from "./roy-agent-core-084qqd7t.js";
+import {
+  HookManager
+} from "./roy-agent-core-w75rafhy.js";
+
+// packages/core/src/env/component.ts
+class BaseComponent {
+  _status = "created";
+  _enabled = true;
+  env;
+  hookManager;
+  constructor() {
+    this.hookManager = new HookManager;
+  }
+  getStatus() {
+    return this._status;
+  }
+  getConfig() {
+    return {
+      name: this.name,
+      version: this.version,
+      enabled: this._enabled,
+      env: this.env
+    };
+  }
+  isEnvInitialized() {
+    return this._status !== "created";
+  }
+  setStatus(status) {
+    this._status = status;
+  }
+  getEnv() {
+    return this.env;
+  }
+  async init(config) {
+    if (config?.env) {
+      this.env = config.env;
+    }
+    this.setStatus("initializing");
+    try {
+      if (config?.name)
+        Object.defineProperty(this, "name", { value: config.name, writable: false });
+      if (config?.version)
+        Object.defineProperty(this, "version", { value: config.version, writable: false });
+    } catch {}
+    if (config?.enabled !== undefined)
+      this._enabled = config.enabled;
+    this.hookManager.setComponentInfo(this.name, this.version);
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async start() {
+    if (this._started)
+      return;
+    this._started = true;
+    await this.onStart();
+    this.setStatus("running");
+  }
+  async stop() {
+    this.setStatus("stopping");
+    this.hookManager.clear();
+    await this.onStop();
+    this.setStatus("stopped");
+  }
+  async onInit() {}
+  async onStart() {}
+  async onStop() {}
+  registerHook(hookPoint, hook) {
+    this.hookManager.register(hookPoint, hook);
+  }
+  addHook(hookPoint, name, fn, priority) {
+    this.hookManager.register(hookPoint, createHook({ name, priority }, fn));
+  }
+  removeHook(hookPoint, name) {
+    return this.hookManager.unregister(hookPoint, name);
+  }
+  async executeHooks(hookPoint, data, metadata) {
+    await this.hookManager.execute(hookPoint, data, metadata);
+  }
+  getConfigComponent() {
+    return this.env?.getComponent("config");
+  }
+  getRuntimeConfig(key, defaultValue) {
+    const configComponent = this.getConfigComponent();
+    if (configComponent) {
+      const value = configComponent.get(key);
+      if (value !== undefined) {
+        return value;
+      }
+    }
+    return defaultValue;
+  }
+}
+
+export { BaseComponent };