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

package/dist/shared/chunk-2b5kbhx3.js

@@ -0,0 +1,366 @@
+import {
+  __esm,
+  __export
+} from "./chunk-wbkh7wat.js";
+
+// src/env/workflow/decorators/decorator-node.ts
+class DecoratorNode {
+  type = "decorator";
+  id;
+  methodName;
+  instance;
+  dependsOn;
+  timeout;
+  retryConfig;
+  constructor(definition) {
+    const config = definition.config;
+    this.id = definition.id;
+    this.methodName = config._methodName;
+    this.instance = config._instance;
+    this.dependsOn = definition.depends_on || [];
+    this.timeout = definition.timeout;
+    this.retryConfig = definition.retry;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    const method = this.instance[this.methodName];
+    if (typeof method !== "function") {
+      return {
+        success: false,
+        error: `Method '${this.methodName}' is not a function`,
+        duration: Date.now() - startTime
+      };
+    }
+    const input = this.prepareInput(context);
+    const result = await this.executeWithRetry(input, context.abort);
+    return {
+      success: !result.error,
+      output: result.output,
+      error: result.error,
+      duration: Date.now() - startTime,
+      metadata: {
+        methodName: this.methodName
+      }
+    };
+  }
+  prepareInput(context) {
+    const nodeOutputs = context.nodeOutputs;
+    if (this.dependsOn.length === 0) {
+      return context.input || {};
+    }
+    const input = {};
+    for (const depId of this.dependsOn) {
+      const depOutput = nodeOutputs instanceof Map ? nodeOutputs.get(depId) : nodeOutputs?.[depId];
+      if (depOutput && typeof depOutput === "object") {
+        if ("output" in depOutput) {
+          input[depId] = depOutput.output;
+        } else {
+          input[depId] = depOutput;
+        }
+      }
+    }
+    return input;
+  }
+  async executeWithRetry(input, abort) {
+    const maxAttempts = this.retryConfig?.max_attempts ?? 1;
+    const backoff = this.retryConfig?.backoff ?? "exponential";
+    const initialDelay = this.retryConfig?.initial_delay ?? 1000;
+    let lastError;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      if (abort?.aborted) {
+        return { error: "Execution aborted" };
+      }
+      try {
+        const output = await this.executeWithTimeout(input, abort);
+        return { output };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < maxAttempts) {
+          const delay = this.calculateBackoff(backoff, initialDelay, attempt - 1);
+          await this.sleep(delay, abort);
+        }
+      }
+    }
+    return { error: lastError?.message || "Unknown error" };
+  }
+  async executeWithTimeout(input, abort) {
+    if (!this.timeout) {
+      return this.instance[this.methodName](input);
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Execution timeout after ${this.timeout}ms`));
+      }, this.timeout);
+    });
+    return Promise.race([
+      this.instance[this.methodName](input),
+      timeoutPromise
+    ]);
+  }
+  calculateBackoff(backoff, initialDelay, attempt) {
+    if (backoff === "exponential") {
+      return initialDelay * Math.pow(2, attempt);
+    }
+    return initialDelay;
+  }
+  sleep(ms, abort) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(resolve, ms);
+      abort?.addEventListener("abort", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+}
+var init_decorator_node = () => {};
+
+// src/env/workflow/nodes/condition-node.ts
+class ConditionNode {
+  definition;
+  type = "condition";
+  id;
+  constructor(definition) {
+    this.definition = definition;
+    this.id = definition.id;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const conditionConfig = this.definition.config?.condition;
+      if (conditionConfig === undefined) {
+        return {
+          output: { success: true, condition: true },
+          error: undefined,
+          durationMs: Date.now() - startTime
+        };
+      }
+      const resolvedCondition = this.resolveCondition(conditionConfig, context);
+      const result = this.evaluateCondition(resolvedCondition);
+      return {
+        output: { success: result, condition: resolvedCondition },
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  resolveCondition(condition, context) {
+    if (typeof condition === "string") {
+      const templateMatch = condition.match(/^\{\{([^}]+)\}\}$/);
+      if (templateMatch) {
+        const path = templateMatch[1].trim();
+        return this.resolveTemplate(path, context);
+      }
+      if (condition === "true")
+        return true;
+      if (condition === "false")
+        return false;
+      return condition;
+    }
+    return condition;
+  }
+  resolveTemplate(path, context) {
+    const trimmed = path.trim();
+    if (trimmed.startsWith("input.")) {
+      const key = trimmed.slice(6);
+      return context.input?.[key];
+    }
+    if (trimmed.startsWith("nodes.")) {
+      const rest = trimmed.slice(6);
+      const segments2 = rest.split(".");
+      const nodeId2 = segments2[0];
+      let nodeOutput2 = context.previousOutputs.get(nodeId2);
+      if (nodeOutput2 === undefined) {
+        const normalizedUnderscore = nodeId2.replace(/-/g, "_");
+        const normalizedHyphen = nodeId2.replace(/_/g, "-");
+        if (normalizedUnderscore !== nodeId2) {
+          nodeOutput2 = context.previousOutputs.get(normalizedUnderscore);
+        }
+        if (nodeOutput2 === undefined && normalizedHyphen !== nodeId2) {
+          nodeOutput2 = context.previousOutputs.get(normalizedHyphen);
+        }
+      }
+      if (nodeOutput2 === undefined)
+        return;
+      let value2 = nodeOutput2;
+      for (const segment of segments2.slice(1)) {
+        if (value2 && typeof value2 === "object") {
+          value2 = value2[segment];
+        } else {
+          return;
+        }
+      }
+      return value2;
+    }
+    const segments = trimmed.split(".");
+    const nodeId = segments[0];
+    let nodeOutput = context.previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, "_");
+      const normalizedHyphen = nodeId.replace(/_/g, "-");
+      if (normalizedUnderscore !== nodeId) {
+        nodeOutput = context.previousOutputs.get(normalizedUnderscore);
+      }
+      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+        nodeOutput = context.previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (nodeOutput === undefined)
+      return;
+    let value = nodeOutput;
+    for (const segment of segments.slice(1)) {
+      if (value && typeof value === "object") {
+        value = value[segment];
+      } else {
+        return;
+      }
+    }
+    return value;
+  }
+  evaluateCondition(value) {
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "string") {
+      return value.toLowerCase() === "true" || value === "1";
+    }
+    if (typeof value === "number") {
+      return value !== 0;
+    }
+    if (value === null || value === undefined) {
+      return false;
+    }
+    if (typeof value === "object") {
+      const obj = value;
+      if ("success" in obj) {
+        return Boolean(obj.success);
+      }
+      return Object.keys(obj).length > 0;
+    }
+    return Boolean(value);
+  }
+}
+var init_condition_node = () => {};
+
+// src/env/workflow/nodes/merge-node.ts
+class MergeNode {
+  definition;
+  type = "merge";
+  id;
+  constructor(definition) {
+    this.definition = definition;
+    this.id = definition.id;
+  }
+  async execute(context) {
+    const startTime = Date.now();
+    try {
+      const strategy = this.definition.config?.strategy || "collect";
+      const deps = this.definition.depends_on || [];
+      const outputs = {};
+      for (const depId of deps) {
+        let output = context.previousOutputs.get(depId);
+        if (output === undefined) {
+          const normalizedUnderscore = depId.replace(/-/g, "_");
+          const normalizedHyphen = depId.replace(/_/g, "-");
+          if (normalizedUnderscore !== depId) {
+            output = context.previousOutputs.get(normalizedUnderscore);
+          }
+          if (output === undefined && normalizedHyphen !== depId) {
+            output = context.previousOutputs.get(normalizedHyphen);
+          }
+        }
+        if (output !== undefined) {
+          outputs[depId] = output;
+        }
+      }
+      let result;
+      switch (strategy) {
+        case "collect":
+          result = outputs;
+          break;
+        case "first":
+          const firstKey = Object.keys(outputs)[0];
+          result = firstKey ? outputs[firstKey] : undefined;
+          break;
+        case "last":
+          const lastKey = Object.keys(outputs).pop();
+          result = lastKey ? outputs[lastKey] : undefined;
+          break;
+        case "merge":
+          result = this.deepMerge(Object.values(outputs));
+          break;
+        default:
+          result = outputs;
+      }
+      return {
+        output: {
+          strategy,
+          results: result,
+          count: Object.keys(outputs).length
+        },
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  deepMerge(objects) {
+    const result = {};
+    for (const obj of objects) {
+      if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+        for (const [key, value] of Object.entries(obj)) {
+          if (result[key] && typeof result[key] === "object" && !Array.isArray(result[key]) && value && typeof value === "object" && !Array.isArray(value)) {
+            result[key] = this.deepMerge([result[key], value]);
+          } else {
+            result[key] = value;
+          }
+        }
+      }
+    }
+    return result;
+  }
+}
+var init_merge_node = () => {};
+
+// src/env/workflow/utils/node-registry-helper.ts
+var exports_node_registry_helper = {};
+__export(exports_node_registry_helper, {
+  registerDecoratorNodeType: () => registerDecoratorNodeType,
+  hasDecoratorNodes: () => hasDecoratorNodes,
+  getDecoratorNodes: () => getDecoratorNodes
+});
+function registerDecoratorNodeType(registry) {
+  registry.register("decorator", (definition) => {
+    return new DecoratorNode(definition);
+  });
+  registry.register("condition", (definition) => {
+    return new ConditionNode(definition);
+  });
+  registry.register("merge", (definition) => {
+    return new MergeNode(definition);
+  });
+}
+function hasDecoratorNodes(nodes) {
+  return nodes.some((node) => node.type === "decorator");
+}
+function getDecoratorNodes(nodes) {
+  return nodes.filter((node) => node.type === "decorator");
+}
+var init_node_registry_helper = __esm(() => {
+  init_decorator_node();
+  init_condition_node();
+  init_merge_node();
+});
+
+export { init_decorator_node, registerDecoratorNodeType, hasDecoratorNodes, getDecoratorNodes, exports_node_registry_helper, init_node_registry_helper };

package/dist/shared/chunk-91bas8w5.js

@@ -0,0 +1,20 @@
+import {
+  closeDatabase,
+  getDatabase,
+  getDatabasePath,
+  initDatabase,
+  initializeTables,
+  resetDatabase
+} from "./chunk-1pf5mfgd.js";
+import"./chunk-a9qmy3sc.js";
+import"./chunk-q9j99fsm.js";
+import"./chunk-1qwabsm0.js";
+import"./chunk-wbkh7wat.js";
+export {
+  resetDatabase,
+  initializeTables,
+  initDatabase,
+  getDatabasePath,
+  getDatabase,
+  closeDatabase
+};

package/dist/shared/chunk-9qzt1v1p.js

@@ -0,0 +1,10 @@
+import {
+  AgentComponentAdapter,
+  init_agent_component_adapter
+} from "./chunk-0q6s9wm6.js";
+import"./chunk-wbkh7wat.js";
+init_agent_component_adapter();
+
+export {
+  AgentComponentAdapter
+};

package/dist/shared/chunk-a9qmy3sc.js

@@ -0,0 +1,296 @@
+import {
+  getTracerProvider,
+  init_tracer_provider
+} from "./chunk-q9j99fsm.js";
+import {
+  __esm,
+  __require
+} from "./chunk-wbkh7wat.js";
+
+// src/env/log-trace/logger.ts
+import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+function simplifyFilePath(fullPath) {
+  let path = fullPath.replace(/\\/g, "/");
+  const bunfsMatch = path.match(/\/\$bunfs\/root\/(.+)$/);
+  if (bunfsMatch) {
+    const virtualPath = bunfsMatch[1];
+    const packagesMatch = virtualPath.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
+    if (packagesMatch) {
+      return packagesMatch[1];
+    }
+    return virtualPath;
+  }
+  const fileProtocolMatch = path.match(/@roy-agent\+core@file\+([^/]+)\/node_modules\/@roy-agent\/core\/(.+)$/);
+  if (fileProtocolMatch) {
+    const rootPkg = fileProtocolMatch[1].replace(/\+/g, "/");
+    const remaining = fileProtocolMatch[2];
+    const prefix = rootPkg;
+    const suffix = remaining.startsWith("src/") ? remaining : `src/${remaining}`;
+    return `${prefix}/${suffix}`;
+  }
+  const packagesRootMatch = path.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
+  if (packagesRootMatch) {
+    return packagesRootMatch[1];
+  }
+  const rootMarkers = ["packages/core/src", "packages/core", "packages"];
+  for (const marker of rootMarkers) {
+    const idx = path.indexOf(marker);
+    if (idx !== -1) {
+      return path.substring(idx);
+    }
+  }
+  return path;
+}
+function getDefaultLogDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  try {
+    const xdg = __require("xdg-basedir");
+    if (xdg.xdgData) {
+      return join(xdg.xdgData, "roy-agent", "logs");
+    }
+  } catch {}
+  return join(home, ".local", "share", "roy-agent", "logs");
+}
+function isQuietMode() {
+  return quietMode;
+}
+function setQuietMode(enabled) {
+  quietMode = enabled;
+}
+function setConfigComponent(component) {
+  configComponentInstance = component;
+}
+function getLogLevel() {
+  if (configComponentInstance) {
+    const level = configComponentInstance.get("log_trace.logging.level");
+    if (level && ["debug", "info", "warn", "error"].includes(level)) {
+      return level;
+    }
+  }
+  const envLevel = process.env.LOG_LEVEL;
+  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+    return envLevel;
+  }
+  return "info";
+}
+function getCategoryLogLevel(category) {
+  if (configComponentInstance) {
+    const levels = configComponentInstance.get("log_trace.logging.levels");
+    if (levels && typeof levels === "object") {
+      const categoryLevel = levels[category];
+      if (categoryLevel && ["debug", "info", "warn", "error"].includes(categoryLevel)) {
+        return categoryLevel;
+      }
+    }
+    const directLevel = configComponentInstance.get(`log_trace.logging.levels.${category}`);
+    if (directLevel && ["debug", "info", "warn", "error"].includes(directLevel)) {
+      return directLevel;
+    }
+  }
+  const envKey = `LOG_LEVEL_${category.toUpperCase().replace(/:/g, "_")}`;
+  const envLevel = process.env[envKey];
+  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+    return envLevel;
+  }
+  return getLogLevel();
+}
+function isAbsolutePath(path) {
+  if (path.startsWith("/")) {
+    return true;
+  }
+  if (/^[a-zA-Z]:[/\\]/.test(path)) {
+    return true;
+  }
+  return false;
+}
+function expandHomeDir(path) {
+  if (path.startsWith("~")) {
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    return join(home, path.slice(1));
+  }
+  return path;
+}
+function getLogFile() {
+  if (configComponentInstance) {
+    const file = configComponentInstance.get("log_trace.logging.file");
+    if (file) {
+      return file;
+    }
+  }
+  return "app.log";
+}
+function getLogDir() {
+  if (configComponentInstance) {
+    const dir = configComponentInstance.get("log_trace.logging.dir");
+    if (dir) {
+      return dir;
+    }
+  }
+  return getDefaultLogDir();
+}
+function getMaxOutput() {
+  if (configComponentInstance) {
+    const maxOutput = configComponentInstance.get("log-trace.logging.maxOutput");
+    if (typeof maxOutput === "number") {
+      return maxOutput;
+    }
+  }
+  return;
+}
+function setLogDirOverride(dir) {
+  logDirOverride = dir;
+}
+
+class Logger {
+  prefix;
+  constructor(prefix) {
+    this.prefix = prefix;
+  }
+  shouldLog(level) {
+    const categoryLevel = getCategoryLogLevel(this.prefix);
+    return levelPriority[level] >= levelPriority[categoryLevel];
+  }
+  ensureLogDirectory(dir) {
+    if (!existsSync(dir)) {
+      try {
+        mkdirSync(dir, { recursive: true });
+      } catch (err) {
+        console.error("[Logger] Failed to create log directory:", dir, err);
+      }
+    }
+  }
+  getCallerLocation() {
+    const originalLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 10;
+    const err = new Error;
+    Error.captureStackTrace(err, this.formatMessage);
+    const stack = err.stack?.split(`
+`) || [];
+    Error.stackTraceLimit = originalLimit;
+    for (let i = 1;i < stack.length; i++) {
+      const line = stack[i];
+      if (line.includes("at ") && !line.includes("logger.ts") && !line.includes("formatMessage")) {
+        const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
+        if (match) {
+          const filePath = match[1];
+          const relativePath = this.getRelativePath(filePath);
+          return {
+            file: relativePath,
+            line: parseInt(match[2], 10)
+          };
+        }
+      }
+    }
+    return null;
+  }
+  getRelativePath(fullPath) {
+    return simplifyFilePath(fullPath);
+  }
+  formatMessage(level, message, data) {
+    const now = new Date;
+    const timestamp = now.toLocaleString("zh-CN", {
+      timeZone: "Asia/Shanghai",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    }).replace(/\//g, "-") + "." + String(now.getMilliseconds()).padStart(3, "0");
+    const prefix = this.prefix ? `[${this.prefix}]` : "";
+    let traceIdStr = "";
+    try {
+      const provider = getTracerProvider();
+      const tracer = provider.getTracer("roy-tracer");
+      const context = tracer.getCurrentContext();
+      if (context?.traceId) {
+        traceIdStr = `[traceId=${context.traceId}]`;
+      }
+    } catch {}
+    let locationStr = "";
+    if (data && typeof data === "object" && "callerLocation" in data) {
+      const logData = data;
+      locationStr = logData.callerLocation ? ` [${logData.callerLocation}]` : "";
+      const { callerLocation: _callerLocation, ...rest } = logData;
+      data = Object.keys(rest).length > 0 ? rest : undefined;
+    } else {
+      const location = this.getCallerLocation();
+      if (location) {
+        locationStr = ` [${location.file}:${location.line}]`;
+      }
+    }
+    let formatted = `${timestamp} [${level.toUpperCase()}]${traceIdStr}${locationStr}${prefix} ${message}`;
+    if (data !== undefined) {
+      if (typeof data === "object") {
+        formatted += " " + JSON.stringify(data).replace(/\n/g, "");
+      } else {
+        formatted += " " + String(data);
+      }
+    }
+    const maxOutput = getMaxOutput();
+    if (maxOutput && maxOutput > 0 && formatted.length > maxOutput) {
+      formatted = formatted.substring(0, maxOutput) + " [TRUNCATED]";
+    }
+    return formatted;
+  }
+  writeToFile(message) {
+    try {
+      const dir = getLogDir();
+      const filename = getLogFile();
+      const expandedDir = expandHomeDir(dir);
+      const resolvedDir = isAbsolutePath(expandedDir) ? expandedDir : join(process.cwd(), expandedDir);
+      this.ensureLogDirectory(resolvedDir);
+      const logFile = join(resolvedDir, filename);
+      appendFileSync(logFile, message + `
+`, "utf-8");
+    } catch (err) {
+      console.error("[Logger] Failed to write to log file:", err);
+    }
+  }
+  log(level, message, data) {
+    if (!this.shouldLog(level))
+      return;
+    const formatted = this.formatMessage(level, message, data);
+    this.writeToFile(formatted);
+    if (!isQuietMode()) {
+      const consoleMethod = level === "error" ? console.error : level === "warn" ? console.warn : level === "info" ? console.log : console.debug;
+      consoleMethod(formatted);
+    }
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+}
+function createLogger(prefix) {
+  if (!loggerCache.has(prefix)) {
+    loggerCache.set(prefix, new Logger(prefix));
+  }
+  return loggerCache.get(prefix);
+}
+function getLogLevels() {
+  return ["debug", "info", "warn", "error"];
+}
+var configComponentInstance = null, quietMode = false, logDirOverride, levelPriority, loggerCache;
+var init_logger = __esm(() => {
+  init_tracer_provider();
+  levelPriority = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  loggerCache = new Map;
+});
+
+export { simplifyFilePath, isQuietMode, setQuietMode, setConfigComponent, getLogLevel, getLogDir, getMaxOutput, setLogDirOverride, createLogger, getLogLevels, init_logger };