@ai-setting/roy-agent-core 1.5.36 → 1.5.40

package/dist/shared/@ai-setting/{roy-agent-core-xt3fx7m1.js → roy-agent-core-15x8fe5h.js}

@@ -2,11 +2,11 @@ import {
   BackgroundTaskManager,
   createDelegateTool,
   createStopTool
-} from "./roy-agent-core-3prpabp8.js";
+} from "./roy-agent-core-v53rfk99.js";
 import {
   SQLiteTaskStore,
   getDefaultTaskDbPath
-} from "./roy-agent-core-bvr1761x.js";
+} from "./roy-agent-core-hsxn8m1j.js";
 import {
   completeTaskTool,
   createTaskTool,
@@ -28,19 +28,26 @@ import {
 import {
   TaskEntityEventTypes
 } from "./roy-agent-core-8gxth0eh.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-cefh9hjv.js";
+} from "./roy-agent-core-4jqq077c.js";
 import {
   globalHookManager
-} from "./roy-agent-core-86gphny5.js";
+} from "./roy-agent-core-jqy2mdyq.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/task/task-component.ts
 init_logger();
@@ -146,6 +153,7 @@ class DefaultTagService {
 }
 
 // src/env/task/task-component.ts
+init_decorator();
 var logger2 = createLogger("task");
 
 class TaskComponent extends BaseComponent {
@@ -410,7 +418,7 @@ class TaskComponent extends BaseComponent {
     return this.store.listTasks(options);
   }
   async completeTask(id, sessionId) {
-    const task = await this.store.updateTask(id, {
+    const task = await this.updateTask(id, {
       status: "completed",
       progress: 100
     });
@@ -453,63 +461,37 @@ class TaskComponent extends BaseComponent {
   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);
-        }
-      });
+  registerHook(hookPoint, hook) {
+    globalHookManager.register(hookPoint, hook);
+    this.plugins.set(this.makePluginKey(hookPoint, hook.name), hook);
+    logger2.debug(`[TaskComponent] Registered hook: ${hook.name} at ${hookPoint}`);
+  }
+  registerHooks(hooks) {
+    for (const { hookPoint, hook } of hooks) {
+      this.registerHook(hookPoint, hook);
     }
-    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}`);
+  unregisterHook(hookPoint, hookName) {
+    const removed = globalHookManager.unregister(hookPoint, hookName);
+    if (removed) {
+      this.plugins.delete(this.makePluginKey(hookPoint, hookName));
+      logger2.info(`[TaskComponent] Unregistered hook: ${hookName} from ${hookPoint}`);
     }
-    this.plugins.delete(name);
-    logger2.info(`[TaskComponent] Unregistered plugin: ${name}`);
-    return true;
+    return removed;
   }
-  listPlugins() {
+  listHooks() {
     return Array.from(this.plugins.values());
   }
+  makePluginKey(hookPoint, hookName) {
+    return `${hookPoint}::${hookName}`;
+  }
+  countHooks(hookPoint) {
+    return globalHookManager.count(hookPoint);
+  }
 }
+__legacyDecorateClassTS([
+  TracedAs("task.component.executeHook", { recordParams: true })
+], TaskComponent.prototype, "executeHook", null);
 // src/env/task/types.ts
 import { z } from "zod";
 var TaskStatusEnum = z.enum(["todo", "active", "completed", "paused", "cancelled"]);

package/dist/shared/@ai-setting/{roy-agent-core-1akcqxj9.js → roy-agent-core-1bfmxx89.js}

@@ -1,7 +1,7 @@
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
 
 // src/env/mcp/tool/adapter.ts
 init_logger();

package/dist/shared/@ai-setting/{roy-agent-core-ty94k28r.js → roy-agent-core-2jnzv9at.js}

@@ -23,11 +23,11 @@ import {
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-zgypchmt.js";
+} from "./roy-agent-core-q5qj0fes.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
 import {
   __esm,
   __export,

package/dist/shared/@ai-setting/{roy-agent-core-3jywqmdd.js → roy-agent-core-2x07feb7.js}

@@ -1,34 +1,25 @@
+import {
+  BasePlugin
+} from "./roy-agent-core-az13yzmc.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-92z6t4he.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-q5qj0fes.js";
+import {
+  getEnvContextOrEmpty
+} from "./roy-agent-core-z33en0cz.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
 import {
+  __legacyDecorateClassTS,
   __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
-// src/env/task/plugins/task-plugin.ts
-class TaskPlugin {
-  config;
-  constructor(config = {}) {
-    this.config = { enabled: true, priority: 0, ...config };
-  }
-  getHookPoints() {
-    return this.hooks.map((h) => h.point);
-  }
-  getPriorityForHook(hookPoint) {
-    const hook = this.hooks.find((h) => h.point === hookPoint);
-    return hook?.priority ?? this.config.priority ?? 0;
-  }
-  isEnabled() {
-    return this.config.enabled ?? true;
-  }
-  setEnabled(enabled) {
-    this.config.enabled = enabled;
-  }
-}
 // src/env/task/plugins/task-tag-plugin.ts
 init_logger();
 
@@ -200,42 +191,49 @@ async function parseExtractorOutput(output) {
 }
 
 // src/env/task/plugins/task-tag-plugin.ts
-var logger = createLogger("task:plugin:tag");
+var logger = createLogger("plugin:task-tag");
 
-class TaskTagPlugin extends TaskPlugin {
-  name = "TaskTagPlugin";
-  hooks = [
-    { point: TaskHookPoints.DELEGATE_BEFORE, priority: 20 },
-    { point: TaskHookPoints.OPERATION_AFTER_CREATE, priority: 10 }
-  ];
+class TaskTagPlugin extends BasePlugin {
+  name = "task-tag";
+  version = "1.0.0";
+  description = "Inject similar task information into delegate prompt and extract workflow on task completion";
+  env;
   taskComponent = null;
   agentComponent = null;
-  constructor(config = {}) {
-    super({ enabled: true, priority: 0, ...config });
+  tagService = null;
+  constructor() {
+    super();
   }
-  static getRequiredAgents() {
-    return [createWorkflowExtractorAgent()];
-  }
-  setComponents(_llmComponent, taskComponent) {
-    this.taskComponent = taskComponent;
-    if (taskComponent?.env) {
-      this.agentComponent = taskComponent.env.getComponent("agent");
+  init(env) {
+    this.env = env;
+    this.taskComponent = env.getComponent("task");
+    if (this.taskComponent && typeof this.taskComponent.getTagService === "function") {
+      this.tagService = this.taskComponent.getTagService();
     }
+    this.agentComponent = env.getComponent("agent");
+    env.registerHook({
+      point: TaskHookPoints.DELEGATE_BEFORE,
+      priority: 20,
+      handler: this.onDelegateBefore.bind(this)
+    });
+    env.registerHook({
+      point: TaskHookPoints.OPERATION_AFTER_CREATE,
+      priority: 10,
+      handler: this.onOperationAfterCreate.bind(this)
+    });
+    env.registerAgent(createWorkflowExtractorAgent());
+    logger.info("[TaskTagPlugin] Initialized");
   }
-  async execute(ctx) {
-    if (!this.config.enabled)
-      return;
-    switch (ctx.hookPoint) {
-      case TaskHookPoints.DELEGATE_BEFORE:
-        await this.onDelegateBefore(ctx);
-        break;
-      case TaskHookPoints.OPERATION_AFTER_CREATE:
-        await this.onOperationAfterCreate(ctx);
-        break;
-    }
+  dispose() {
+    this.env = null;
+    this.taskComponent = null;
+    this.agentComponent = null;
+    this.tagService = null;
+    logger.info("[TaskTagPlugin] Disposed");
   }
   async onDelegateBefore(ctx) {
-    const { taskId, tagService, prompt } = ctx.data;
+    const data = ctx.data;
+    const { taskId, prompt } = data;
     if (!taskId || !this.taskComponent) {
       return;
     }
@@ -246,15 +244,14 @@ class TaskTagPlugin extends TaskPlugin {
       const keywords = this.extractKeywords(currentTask);
       if (keywords.length === 0)
         return;
-      const tagServiceForSearch = tagService;
-      const similarTasks = await tagServiceForSearch?.findSimilarTasksByKeywords?.(keywords, {
+      const similarTasks = await this.tagService?.findSimilarTasksByKeywords?.(keywords, {
         limit: 5,
         excludeTaskId: taskId
       }) ?? [];
       if (similarTasks.length === 0)
         return;
       const hint = this.formatSimilarTasks(similarTasks);
-      ctx.data.prompt = `${hint}
+      data.prompt = `${hint}
 
 ---
 
@@ -314,7 +311,7 @@ ${prompt}`;
         return;
       const operations = await this.taskComponent?.listOperations({ taskId }) ?? [];
       const allSessionIds = [...new Set([sessionId, ...operations.map((op) => op.sessionId).filter(Boolean)])];
-      const sessionComponent = this.taskComponent?.env?.getComponent("session");
+      const sessionComponent = this.env.getComponent("session");
       const allMessages = [];
       for (const sid of allSessionIds) {
         try {
@@ -355,23 +352,24 @@ ${prompt}`;
         actionTitle: `Workflow extracted: ${workflow.name}`,
         actionDescription: workflow.id
       });
-      logger.info(`Workflow extracted: ${workflow.id}`);
+      logger.info(`[TaskTagPlugin] Workflow extracted: ${workflow.id}`);
     } catch (error) {
-      logger.warn(`Workflow extraction failed: ${error}`);
+      logger.warn(`[TaskTagPlugin] Workflow extraction failed: ${error}`);
     }
   }
+  _workflowRepo = null;
   async getWorkflowRepository() {
-    const workflowComponent = this.taskComponent?.env?.getComponent("workflow");
+    const workflowComponent = this.env.getComponent("workflow");
     if (workflowComponent?.workflowService?.workflowRepository) {
       return workflowComponent.workflowService.workflowRepository;
     }
     if (!this._workflowRepo) {
       try {
-        const sqlite = await import("./roy-agent-core-wft9ra24.js");
+        const sqlite = await import("./roy-agent-core-zwp3jp02.js");
         this.ensureDataDir();
         const db = sqlite.getDatabase();
         sqlite.initializeTables();
-        const { WorkflowRepository } = await import("./roy-agent-core-bcbqy27c.js");
+        const { WorkflowRepository } = await import("./roy-agent-core-ty33mnr7.js");
         this._workflowRepo = new WorkflowRepository(db);
         return this._workflowRepo;
       } catch {
@@ -382,12 +380,266 @@ ${prompt}`;
   }
   ensureDataDir() {
     const { join } = __require("path");
-    const { mkdirSync, existsSync } = __require("fs");
-    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-    const dataDir = join(home, ".local", "share", "roy-agent");
-    if (!existsSync(dataDir))
-      mkdirSync(dataDir, { recursive: true });
+    const dataDir = join(process.env.XDG_DATA_HOME || join(process.env.HOME || "", ".local/share"), "roy-agent");
+    __require("fs").mkdirSync(dataDir, { recursive: true });
   }
-  _workflowRepo = null;
 }
-export { TaskPlugin, WORKFLOW_EXTRACTOR_PROMPT, createWorkflowExtractorAgent, formatExtractorInput, formatExtractorInputFromDescription, parseExtractorOutput, TaskTagPlugin };
+// src/env/task/plugins/lark-cli-task-notify-plugin.ts
+init_decorator();
+init_logger();
+import { spawn } from "child_process";
+var logger2 = createLogger("lark-cli:task-notify");
+function isTaskNotifyDebugEnabled() {
+  return process.env.ROY_TASK_NOTIFY_DEBUG === "1" || process.env.ROY_TRACE_DEBUG === "1";
+}
+var NotifyType;
+((NotifyType2) => {
+  NotifyType2["TASK_CREATED"] = "task_created";
+  NotifyType2["TASK_COMPLETED"] = "task_completed";
+  NotifyType2["TASK_UPDATED"] = "task_updated";
+  NotifyType2["TASK_FAILED"] = "task_failed";
+})(NotifyType ||= {});
+
+class LarkCliTaskNotifyHook {
+  name;
+  priority;
+  description;
+  pluginName;
+  sourceId;
+  config;
+  constructor(config = {}) {
+    this.name = config.pluginName || "LarkCliTaskNotifyHook";
+    this.priority = config.priority ?? 5;
+    this.description = "LarkCli 任务通知 Hook";
+    this.pluginName = config.pluginName;
+    this.sourceId = config.sourceId;
+    this.config = {
+      enabled: true,
+      priority: 5,
+      notifyTypes: ["task_completed" /* TASK_COMPLETED */],
+      ...config
+    };
+  }
+  async execute(ctx) {
+    if (!this.config.enabled) {
+      return;
+    }
+    const env = getEnvContextOrEmpty();
+    if (this.pluginName && this.sourceId) {
+      const key = `${this.sourceId}:${this.pluginName}`;
+      if (env.pluginEnabled && env.pluginEnabled[key] !== true) {
+        logger2.debug(`Plugin not enabled for source: ${key}`);
+        return;
+      }
+    }
+    switch (ctx.hookPoint) {
+      case TaskHookPoints.AFTER_CREATE:
+        await this.onAfterCreate(ctx);
+        break;
+      case TaskHookPoints.AFTER_UPDATE:
+        await this.onAfterUpdate(ctx);
+        break;
+    }
+  }
+  async onAfterCreate(ctx) {
+    const { task } = ctx.data;
+    if (!this.shouldNotify("task_created" /* TASK_CREATED */))
+      return;
+    await this.sendNotify({
+      type: "task_created" /* TASK_CREATED */,
+      title: `\uD83D\uDCDD 任务已创建`,
+      content: this.formatTaskCreated(task)
+    });
+  }
+  async onAfterUpdate(ctx) {
+    const hookCtx = ctx.data;
+    const innerData = hookCtx.data;
+    if (!innerData) {
+      return;
+    }
+    const { task, changes } = innerData;
+    if (!task) {
+      return;
+    }
+    let notifyType;
+    let notifyChanges = changes || {};
+    if (changes?.status === "completed" || changes?.progress === 100) {
+      notifyType = "task_completed" /* TASK_COMPLETED */;
+    } else if (changes?.status) {
+      notifyType = "task_updated" /* TASK_UPDATED */;
+    } else if (task.status === "completed" || task.progress === 100) {
+      notifyType = "task_completed" /* TASK_COMPLETED */;
+      notifyChanges = { status: task.status, progress: task.progress };
+    } else if (changes && Object.keys(changes).length > 0) {
+      notifyType = "task_updated" /* TASK_UPDATED */;
+    } else {
+      return;
+    }
+    if (!this.shouldNotify(notifyType)) {
+      return;
+    }
+    await this.sendNotify({
+      type: notifyType,
+      title: this.getNotifyTitle(notifyType),
+      content: this.formatTaskUpdate(task, notifyChanges),
+      _hookContext: ctx
+    });
+  }
+  async sendNotify(options) {
+    const { type, title, content, _hookContext } = options;
+    const env = getEnvContextOrEmpty();
+    let replyChannel = env.replyChannel;
+    const envContextFromMetadata = env.metadata?.envContext;
+    if (!replyChannel && envContextFromMetadata) {
+      replyChannel = envContextFromMetadata.replyChannel;
+    }
+    if (!replyChannel && _hookContext?.metadata?.envContext) {
+      replyChannel = _hookContext.metadata.envContext.replyChannel;
+    }
+    const chatId = replyChannel?.chatId;
+    const messageId = replyChannel?.messageId;
+    if (!chatId && !messageId) {
+      logger2.debug(`No replyChannel available for ${type}`);
+      return;
+    }
+    const message = `${title}
+
+${content}`;
+    try {
+      if (isTaskNotifyDebugEnabled()) {
+        logger2.debug(`Sending message - messageId: ${messageId}`);
+      }
+      await this.sendLarkMessage({
+        chatId,
+        messageId,
+        content: message
+      });
+      logger2.info(`Notification sent: ${type}`);
+    } catch (error) {
+      logger2.error(`Failed to send notification: ${error}`);
+    }
+  }
+  sendLarkMessage(options) {
+    return new Promise((resolve, reject) => {
+      const { chatId, messageId, content } = options;
+      const contentJson = JSON.stringify({ text: content });
+      let args;
+      if (messageId) {
+        args = [
+          "im",
+          "+messages-reply",
+          "--message-id",
+          messageId,
+          "--text",
+          contentJson,
+          "--as",
+          "bot"
+        ];
+      } else {
+        args = [
+          "im",
+          "+messages-send",
+          "--chat-id",
+          chatId,
+          "--text",
+          contentJson
+        ];
+      }
+      const proc = spawn("lark-cli", args, {
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          logger2.debug(`lark-cli output: ${stdout}`);
+          resolve();
+        } else {
+          reject(new Error(`lark-cli exited with code ${code}: ${stderr}`));
+        }
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  shouldNotify(type) {
+    const { notifyTypes } = this.config;
+    if (notifyTypes && notifyTypes.length === 0)
+      return true;
+    if (notifyTypes)
+      return notifyTypes.includes(type);
+    return type === "task_completed" /* TASK_COMPLETED */;
+  }
+  getNotifyTitle(type) {
+    const template = this.config.templates?.[type];
+    if (template)
+      return template;
+    switch (type) {
+      case "task_created" /* TASK_CREATED */:
+        return "\uD83D\uDCDD 任务已创建";
+      case "task_completed" /* TASK_COMPLETED */:
+        return "✅ 任务已完成";
+      case "task_updated" /* TASK_UPDATED */:
+        return "\uD83D\uDCCB 任务已更新";
+      case "task_failed" /* TASK_FAILED */:
+        return "❌ 任务执行失败";
+      default:
+        return "\uD83D\uDCEC 任务通知";
+    }
+  }
+  formatTaskCreated(task) {
+    const lines = [
+      `**标题**: ${task.title || "无标题"}`
+    ];
+    if (task.description) {
+      lines.push(`**描述**: ${task.description.substring(0, 100)}${task.description.length > 100 ? "..." : ""}`);
+    }
+    if (task.priority) {
+      lines.push(`**优先级**: ${task.priority}`);
+    }
+    return lines.join(`
+`);
+  }
+  formatTaskUpdate(task, changes) {
+    const lines = [
+      `**标题**: ${task.title || "无标题"}`,
+      `**ID**: ${task.id}`
+    ];
+    if (changes?.status) {
+      lines.push(`**状态**: ${changes.status}`);
+    }
+    if (changes?.progress !== undefined) {
+      lines.push(`**进度**: ${changes.progress}%`);
+    }
+    if (changes?.current_status) {
+      lines.push(`**当前状态**: ${changes.current_status}`);
+    }
+    const changeKeys = Object.keys(changes || {}).filter((k) => !["status", "progress", "current_status"].includes(k));
+    if (changeKeys.length > 0) {
+      lines.push(`**变更**: ${changeKeys.join(", ")}`);
+    }
+    return lines.join(`
+`);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("lark-cli-task-notify.execute")
+], LarkCliTaskNotifyHook.prototype, "execute", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-cli-task-notify.sendNotify")
+], LarkCliTaskNotifyHook.prototype, "sendNotify", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-cli-task-notify.sendLarkMessage")
+], LarkCliTaskNotifyHook.prototype, "sendLarkMessage", null);
+function createLarkCliTaskNotifyHook(config = {}) {
+  return new LarkCliTaskNotifyHook(config);
+}
+export { WORKFLOW_EXTRACTOR_PROMPT, createWorkflowExtractorAgent, formatExtractorInput, formatExtractorInputFromDescription, parseExtractorOutput, TaskTagPlugin, NotifyType, LarkCliTaskNotifyHook, createLarkCliTaskNotifyHook };

package/dist/shared/@ai-setting/{roy-agent-core-cefh9hjv.js → roy-agent-core-4jqq077c.js}

@@ -3,7 +3,7 @@ import {
 } from "./roy-agent-core-2dhd60aw.js";
 import {
   HookManager
-} from "./roy-agent-core-86gphny5.js";
+} from "./roy-agent-core-jqy2mdyq.js";
 
 // src/env/component.ts
 class BaseComponent {