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

package/dist/shared/{chunk-0q6s9wm6.js → @ai-setting/roy-agent-core-pc9g3962.js}

@@ -1,54 +1,10 @@
+import {
+  AskUserError,
+  init_workflow_hil
+} from "./roy-agent-core-e25xkv53.js";
 import {
   __esm
-} from "./chunk-wbkh7wat.js";
-
-// src/env/workflow/types/workflow-hil.ts
-function createNodeInterruptEvent(runId, nodeId, nodeType, query, agentSessionId) {
-  return {
-    type: "node.interrupt",
-    run_id: runId,
-    timestamp: Date.now(),
-    node_id: nodeId,
-    node_type: nodeType,
-    query,
-    ...agentSessionId ? { agent_session_id: agentSessionId } : {}
-  };
-}
-var AskUserError;
-var init_workflow_hil = __esm(() => {
-  AskUserError = class AskUserError extends Error {
-    runId;
-    sessionId;
-    nodeId;
-    nodeType;
-    query;
-    agentSessionId;
-    timestamp;
-    type = "ask-user";
-    name = "AskUserError";
-    constructor(runId, sessionId, nodeId, nodeType, query, agentSessionId, timestamp = Date.now()) {
-      super(`[${nodeType}:${nodeId}] Ask user: ${query}`);
-      this.runId = runId;
-      this.sessionId = sessionId;
-      this.nodeId = nodeId;
-      this.nodeType = nodeType;
-      this.query = query;
-      this.agentSessionId = agentSessionId;
-      this.timestamp = timestamp;
-    }
-    toEvent() {
-      return {
-        type: "workflow.ask-user",
-        run_id: this.runId,
-        timestamp: this.timestamp,
-        session_id: this.sessionId,
-        node_id: this.nodeId,
-        node_type: this.nodeType,
-        query: this.query
-      };
-    }
-  };
-});
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/nodes/agent-component-adapter.ts
 class AgentComponentAdapter {
@@ -246,4 +202,4 @@ var init_agent_component_adapter = __esm(() => {
   init_workflow_hil();
 });
 
-export { createNodeInterruptEvent, AskUserError, init_workflow_hil, AgentComponentAdapter, init_agent_component_adapter };
+export { AgentComponentAdapter, init_agent_component_adapter };

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

@@ -0,0 +1,60 @@
+// src/env/skill/types.ts
+import { z } from "zod";
+var SkillToolSchema = z.object({
+  skill: z.string().describe("Skill name to load")
+});
+
+// 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-pzsg9pvf.js

@@ -0,0 +1,393 @@
+import {
+  createMemoryTools
+} from "./roy-agent-core-g1s2h0e5.js";
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-rbetrphj.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-j3wc4465.js";
+
+// src/env/memory/types.ts
+import { z } from "zod";
+var RecordMemorySchema = z.object({
+  scope: z.enum(["project", "global"]).describe("作用域: project/global"),
+  mode: z.enum(["append", "prepend", "overwrite", "delete"]).describe("模式: append(追加)/prepend(插入)/overwrite(覆盖)/delete(删除)"),
+  content: z.string().optional().describe("记忆内容"),
+  title: z.string().optional().describe("章节标题")
+});
+var RecallMemorySchema = z.object({
+  scope: z.enum(["project", "global"]).optional().describe("作用域（可选，不传则读取所有）")
+});
+// src/env/memory/memory-config.ts
+import path from "path";
+import os from "os";
+var DEFAULT_MEMORY_CONFIG = {
+  memoryPaths: [
+    {
+      type: "global",
+      path: path.join(os.homedir(), ".config", "roy-agent", "memory")
+    },
+    {
+      type: "project",
+      path: ".roy/memory"
+    }
+  ],
+  recursive: true,
+  cacheEnabled: true,
+  cacheTTL: 5 * 60 * 1000
+};
+var SOURCE_PRIORITY = {
+  global: 0,
+  project: 1
+};
+function getSourcePriority(source) {
+  return SOURCE_PRIORITY[source] ?? 0;
+}
+// src/env/memory/memory-component.ts
+init_logger();
+
+// src/env/memory/memory-config-registration.ts
+import path2 from "path";
+import os2 from "os";
+var MEMORY_DEFAULTS = {
+  "memory.recursive": true,
+  "memory.cacheEnabled": true,
+  "memory.cacheTTL": 300000,
+  "memory.memoryFile": "memory.md",
+  "memory.memoryPaths": [
+    { type: "global", path: path2.join(os2.homedir(), ".config", "roy-agent", "memory") },
+    { type: "project", path: ".roy/memory" }
+  ]
+};
+var MEMORY_CONFIG_REGISTRATION = {
+  name: "memory",
+  sources: [
+    { type: "env", envPrefix: "MEMORY", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "memory.recursive", sources: ["env", "file"] },
+    { key: "memory.cacheEnabled", sources: ["env", "file"] },
+    { key: "memory.cacheTTL", sources: ["env", "file"] },
+    { key: "memory.memoryPaths", sources: ["env", "file"] },
+    { key: "memory.memoryFile", sources: ["env", "file"] }
+  ]
+};
+
+// src/env/memory/memory-component.ts
+import path3 from "path";
+import fs from "fs/promises";
+var logger = createLogger("memory");
+
+class MemoryComponent extends BaseComponent {
+  name = "memory";
+  version = "2.0.0";
+  config;
+  toolComponent;
+  configComponent;
+  cache = new Map;
+  configWatcher;
+  async init(config) {
+    await super.init(config);
+    const options = config?.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for MemoryComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    logger.info("[MemoryComponent] Initialized (simplified)");
+  }
+  async registerConfig(options) {
+    const configComponent = this.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix ?? "MEMORY";
+    configComponent.registerComponent(MEMORY_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("memory");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "memory");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(MEMORY_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+    this.buildConfig(configComponent);
+  }
+  buildConfig(configComponent) {
+    const recursive = configComponent.get("memory.recursive") ?? true;
+    const cacheEnabled = configComponent.get("memory.cacheEnabled") ?? true;
+    const cacheTTL = configComponent.get("memory.cacheTTL") ?? 300000;
+    const memoryFile = configComponent.get("memory.memoryFile") ?? "memory.md";
+    const memoryPathsConfig = configComponent.get("memory.memoryPaths");
+    let memoryPaths = [];
+    if (Array.isArray(memoryPathsConfig)) {
+      memoryPaths = memoryPathsConfig;
+    } else if (typeof memoryPathsConfig === "string") {
+      try {
+        memoryPaths = JSON.parse(memoryPathsConfig);
+      } catch {
+        memoryPaths = DEFAULT_MEMORY_CONFIG.memoryPaths;
+      }
+    }
+    if (memoryPaths.length === 0) {
+      memoryPaths = DEFAULT_MEMORY_CONFIG.memoryPaths;
+    }
+    this.config = {
+      memoryPaths,
+      recursive,
+      cacheEnabled,
+      cacheTTL,
+      memoryFile
+    };
+  }
+  flattenConfig(obj, prefix = "memory") {
+    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("memory.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    logger.info(`[MemoryComponent] Config changed: ${event.key}`, {
+      oldValue: event.oldValue,
+      newValue: event.newValue
+    });
+    if (this.configComponent) {
+      this.buildConfig(this.configComponent);
+    }
+    this.cache.clear();
+  }
+  async start() {
+    await super.start();
+    this.toolComponent = this.env?.getComponent("tool");
+    if (!this.toolComponent) {
+      logger.warn("[MemoryComponent] ToolComponent not found, skipping tool registration");
+      return;
+    }
+    await this.registerTools();
+    this.setStatus("running");
+    logger.info(`[MemoryComponent] Started with ${this.toolComponent.getToolCount()} tools`);
+  }
+  async stop() {
+    if (this.configWatcher) {
+      this.configWatcher();
+      this.configWatcher = undefined;
+    }
+    if (this.toolComponent) {
+      this.toolComponent.unregister("record_memory");
+      this.toolComponent.unregister("recall_memory");
+    }
+    this.cache.clear();
+    await super.stop();
+    logger.info("[MemoryComponent] Stopped");
+  }
+  async registerTools() {
+    if (!this.toolComponent)
+      return;
+    const tools = createMemoryTools((args) => this.recordMemory(args), (scope) => this.recallMemory(scope), {
+      getMemoryPaths: () => this.getMemoryPaths(),
+      getMemoryFile: () => this.getMemoryFile()
+    });
+    for (const tool of tools) {
+      this.toolComponent.register(tool);
+    }
+    logger.info("[MemoryComponent] Registered memory tools");
+  }
+  getMemoryPaths() {
+    return this.config.memoryPaths;
+  }
+  updateMemoryPaths(paths) {
+    this.config.memoryPaths = paths;
+    this.clearCache();
+  }
+  getMemoryFile() {
+    return this.config.memoryFile ?? "memory.md";
+  }
+  async recordMemory(args) {
+    const { mode, content, title, filename, scope } = args;
+    const memoryFile = filename ?? this.getMemoryFile();
+    const paths = this.config.memoryPaths;
+    if (paths.length === 0) {
+      return null;
+    }
+    let basePath;
+    if (scope) {
+      const targetPath = paths.find((p) => p.type === scope);
+      if (!targetPath) {
+        logger.warn(`[recordMemory] No ${scope} path configured, using first available path`);
+        basePath = paths[0].path;
+      } else {
+        basePath = targetPath.path;
+      }
+    } else {
+      basePath = paths[0].path;
+    }
+    const filePath = path3.join(basePath, memoryFile);
+    try {
+      let existingContent = "";
+      let fileExists = false;
+      try {
+        existingContent = await fs.readFile(filePath, "utf-8");
+        fileExists = true;
+      } catch {}
+      let newContent;
+      let action;
+      switch (mode) {
+        case "delete":
+          if (fileExists) {
+            await fs.unlink(filePath);
+            this.clearCache();
+            return { path: filePath, action: "delete" };
+          }
+          return null;
+        case "overwrite":
+          if (title && content) {
+            newContent = `## ${title}
+
+${content}
+`;
+          } else {
+            newContent = content ?? "";
+          }
+          action = fileExists ? "overwrite" : "created";
+          break;
+        case "append":
+          if (!content) {
+            throw new Error("content is required for append mode");
+          }
+          if (title) {
+            newContent = existingContent + `
+## ${title}
+
+${content}
+`;
+          } else {
+            newContent = existingContent + `
+${content}
+`;
+          }
+          action = fileExists ? "append" : "created";
+          break;
+        case "prepend":
+          if (!content) {
+            throw new Error("content is required for prepend mode");
+          }
+          if (title) {
+            newContent = `## ${title}
+
+${content}
+
+---
+
+${existingContent}`;
+          } else {
+            newContent = `${content}
+
+---
+
+${existingContent}`;
+          }
+          action = fileExists ? "prepend" : "created";
+          break;
+        default:
+          throw new Error(`Unknown mode: ${mode}`);
+      }
+      await fs.mkdir(basePath, { recursive: true });
+      await fs.writeFile(filePath, newContent, "utf-8");
+      this.clearCache();
+      return { path: filePath, action };
+    } catch (error) {
+      logger.error(`[recordMemory] Failed: ${error}`);
+      throw error;
+    }
+  }
+  async recallMemory(scope) {
+    const memoryFile = this.getMemoryFile();
+    const paths = this.config.memoryPaths;
+    const results = [];
+    for (const memoryPath of paths) {
+      if (scope && memoryPath.type !== scope) {
+        continue;
+      }
+      const filePath = path3.join(memoryPath.path, memoryFile);
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        if (content.trim()) {
+          results.push(`## [${memoryPath.type}] ${memoryFile}
+${content}`);
+        }
+      } catch {}
+    }
+    return results.join(`
+
+`);
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  getCache(key) {
+    if (!this.config.cacheEnabled)
+      return;
+    const entry = this.cache.get(key);
+    if (!entry)
+      return;
+    const age = Date.now() - entry.timestamp;
+    if (age > (this.config.cacheTTL ?? 300000)) {
+      this.cache.delete(key);
+      return;
+    }
+    return entry.data;
+  }
+  setCache(key, data) {
+    if (!this.config.cacheEnabled)
+      return;
+    this.cache.set(key, { data, timestamp: Date.now() });
+  }
+}
+export { DEFAULT_MEMORY_CONFIG, SOURCE_PRIORITY, getSourcePriority, MemoryComponent };

package/dist/shared/{chunk-91bas8w5.js → @ai-setting/roy-agent-core-q779wnwm.js}

@@ -5,11 +5,11 @@ import {
   initDatabase,
   initializeTables,
   resetDatabase
-} from "./chunk-1pf5mfgd.js";
-import"./chunk-a9qmy3sc.js";
-import"./chunk-q9j99fsm.js";
-import"./chunk-1qwabsm0.js";
-import"./chunk-wbkh7wat.js";
+} from "./roy-agent-core-37e4tep3.js";
+import"./roy-agent-core-j3wc4465.js";
+import"./roy-agent-core-fv32jaa8.js";
+import"./roy-agent-core-bncgx3gb.js";
+import"./roy-agent-core-fs0mn2jk.js";
 export {
   resetDatabase,
   initializeTables,

package/dist/shared/{chunk-25x2pdtp.js → @ai-setting/roy-agent-core-qw0ebh1d.js}

@@ -1,6 +1,6 @@
 import {
   __esm
-} from "./chunk-wbkh7wat.js";
+} from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/utils/session-recovery.ts
 function inferNextNode(messages, definition) {

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

@@ -0,0 +1,57 @@
+// src/config/env-key.ts
+function toEnvKey(key, prefix) {
+  let keyNormalized = key.replace(/[.-]/g, "_");
+  keyNormalized = keyNormalized.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/_+/g, "_").toUpperCase();
+  if (prefix) {
+    const separator = prefix.endsWith("_") ? "" : "_";
+    return `${prefix}${separator}${keyNormalized}`;
+  }
+  return keyNormalized;
+}
+function fromEnvKey(envKey, prefix) {
+  if (!prefix) {
+    return envKey;
+  }
+  if (envKey.startsWith(prefix)) {
+    const afterPrefix = envKey.slice(prefix.length);
+    if (afterPrefix.startsWith("_")) {
+      return afterPrefix.slice(1);
+    }
+    return afterPrefix;
+  }
+  return envKey;
+}
+function envKeyToConfigKey(envKey, prefix, componentName) {
+  const prefixUpper = prefix.toUpperCase();
+  if (!envKey.startsWith(prefixUpper)) {
+    return;
+  }
+  const componentUpperNormalized = componentName.replace(/-/g, "_").toUpperCase();
+  let keyPart = envKey.slice(prefixUpper.length);
+  if (keyPart.startsWith("_")) {
+    keyPart = keyPart.slice(1);
+  }
+  if (!keyPart) {
+    return;
+  }
+  const firstUnderscore = keyPart.indexOf("_");
+  let restPart;
+  if (firstUnderscore === -1) {
+    restPart = keyPart;
+  } else {
+    const firstPart = keyPart.slice(0, firstUnderscore);
+    const remaining = keyPart.slice(firstUnderscore + 1);
+    if (firstPart === componentUpperNormalized) {
+      restPart = remaining;
+    } else {
+      restPart = keyPart;
+    }
+  }
+  if (!restPart) {
+    return;
+  }
+  const restPartConverted = restPart.replace(/_/g, ".");
+  return `${componentName}.${restPartConverted.toLowerCase()}`;
+}
+
+export { toEnvKey, fromEnvKey, envKeyToConfigKey };

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

@@ -0,0 +1,66 @@
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/paths.ts
+import os from "os";
+import path from "path";
+var APP_NAME = "roy-agent";
+function getXdgBase() {
+  const home = os.homedir();
+  try {
+    const xdg = __require("xdg-basedir");
+    return {
+      config: xdg.xdgConfig || path.join(home, ".config"),
+      state: xdg.xdgState || path.join(home, ".local", "state"),
+      data: xdg.xdgData || path.join(home, ".local", "share"),
+      cache: xdg.xdgCache || path.join(home, ".cache")
+    };
+  } catch {
+    return {
+      config: path.join(home, ".config"),
+      state: path.join(home, ".local", "state"),
+      data: path.join(home, ".local", "share"),
+      cache: path.join(home, ".cache")
+    };
+  }
+}
+function computeXDGPaths() {
+  const home = os.homedir();
+  const xdg = getXdgBase();
+  return {
+    home,
+    config: path.join(xdg.config, APP_NAME),
+    state: path.join(xdg.state, APP_NAME),
+    data: path.join(xdg.data, APP_NAME),
+    cache: path.join(xdg.cache, APP_NAME)
+  };
+}
+
+class XDGPathsCalculator {
+  _paths;
+  get paths() {
+    if (!this._paths) {
+      this._paths = computeXDGPaths();
+    }
+    return this._paths;
+  }
+  getPath(type) {
+    return this.paths[type];
+  }
+  getComponentPath(base, subPath) {
+    return path.join(this.paths[base], subPath);
+  }
+  reset() {
+    this._paths = undefined;
+  }
+}
+var XDG_PATHS = new XDGPathsCalculator;
+function getXDGPaths() {
+  return XDG_PATHS.paths;
+}
+function getXDGPath(type) {
+  return XDG_PATHS.getPath(type);
+}
+
+export { XDG_PATHS, getXDGPaths, getXDGPath };