@ai-setting/roy-agent-core 1.5.15-test → 1.5.17-beta.1

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 };

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

@@ -0,0 +1,10 @@
+import {
+  SQLiteSpanStorage,
+  init_span_storage
+} from "./roy-agent-core-psv4v63c.js";
+import"./roy-agent-core-fs0mn2jk.js";
+init_span_storage();
+
+export {
+  SQLiteSpanStorage
+};

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

@@ -0,0 +1,267 @@
+import {
+  exports_node_registry_helper,
+  init_node_registry_helper
+} from "./roy-agent-core-0rtxwr28.js";
+import {
+  WorkflowEngine,
+  exports_engine,
+  init_engine
+} from "./roy-agent-core-wrcy0h6z.js";
+import {
+  WorkflowService
+} from "./roy-agent-core-4t40mkpv.js";
+import {
+  askUserTool
+} from "./roy-agent-core-0vbdz0x7.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+import {
+  __require,
+  __toCommonJS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/workflow-component.ts
+import"reflect-metadata";
+init_engine();
+init_logger();
+init_engine();
+init_node_registry_helper();
+var componentLogger = createLogger("workflow");
+
+class SkillRegistryAdapter {
+  skillComponent;
+  constructor(skillComponent) {
+    this.skillComponent = skillComponent;
+  }
+  getSkill(name) {
+    const entry = this.skillComponent.getSkill(name);
+    if (!entry)
+      return;
+    return {
+      name: entry.name,
+      invoke: async (input, context) => {
+        return entry.content;
+      }
+    };
+  }
+  hasSkill(name) {
+    return this.skillComponent.hasSkill(name);
+  }
+}
+
+class WorkflowComponent extends BaseComponent {
+  name = "workflow";
+  version = "1.0.0";
+  workflowService = null;
+  sessionComponent = null;
+  nodeRegistry = null;
+  decoratorsRegistered = false;
+  getService() {
+    return this.workflowService;
+  }
+  toolComponent;
+  llmComponent;
+  logTraceComponent;
+  _workflowEnv;
+  skillRegistry;
+  agentRunner;
+  async init(options) {
+    const opts = options;
+    this._status = "initializing";
+    componentLogger.info("Initializing WorkflowComponent...");
+    this.toolComponent = opts.toolComponent;
+    this.llmComponent = opts.llmComponent;
+    this.logTraceComponent = opts.logTraceComponent;
+    this._workflowEnv = opts.env;
+    this.skillRegistry = opts.skillRegistry;
+    this.agentRunner = opts.agentRunner;
+    try {
+      if (opts.autoRegisterDecorators !== false) {
+        await this.registerDecorators();
+      }
+      this._status = "ready";
+      componentLogger.info("WorkflowComponent initialized successfully");
+    } catch (error) {
+      this._status = "error";
+      componentLogger.error("Failed to initialize WorkflowComponent:", error);
+      throw error;
+    }
+  }
+  async registerDecorators() {
+    if (this.decoratorsRegistered)
+      return;
+    try {
+      const { NodeRegistry } = await import("../../env/workflow/engine/index.js");
+      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-9yxb3ty9.js");
+      this.nodeRegistry = new NodeRegistry;
+      registerDecoratorNodeType2(this.nodeRegistry);
+      this.decoratorsRegistered = true;
+      componentLogger.info("Decorator node type registered");
+    } catch (error) {
+      componentLogger.error("Failed to register decorator node type:", error);
+      throw error;
+    }
+  }
+  createService(options) {
+    const skillRegistryAdapter = options.skillRegistry ? new SkillRegistryAdapter(options.skillRegistry) : undefined;
+    const sessionComponentForEngine = options.sessionComponent;
+    const engineFactory = (workflow, opts) => {
+      const { NodeRegistry, WorkflowEngine: WorkflowEngine2 } = (init_engine(), __toCommonJS(exports_engine));
+      const registry = new NodeRegistry({
+        toolRegistry: options.toolComponent,
+        agentComponent: options.env?.getComponent("agent"),
+        skillRegistry: skillRegistryAdapter,
+        sessionComponent: sessionComponentForEngine
+      });
+      const { registerDecoratorNodeType: registerDecoratorNodeType2 } = (init_node_registry_helper(), __toCommonJS(exports_node_registry_helper));
+      registerDecoratorNodeType2(registry);
+      return new WorkflowEngine2(registry, sessionComponentForEngine, options.workflowRepository);
+    };
+    this.workflowService = new WorkflowService(options.workflowRepository, engineFactory, options.sessionComponent);
+    return this.workflowService;
+  }
+  async runWorkflow(definition, input, options) {
+    const { NodeRegistry } = await import("../../env/workflow/engine/index.js");
+    const { registerDecoratorNodeType: registerDecoratorNodeType2 } = await import("./roy-agent-core-9yxb3ty9.js");
+    const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
+    const skillComponent = this._workflowEnv?.getComponent("skill");
+    let agentRunner = this.agentRunner;
+    if (!agentRunner && this._workflowEnv) {
+      const agentComponent = this._workflowEnv.getComponent("agent");
+      if (agentComponent) {
+        const { AgentComponentAdapter } = await import("./roy-agent-core-dh9d7a3m.js");
+        agentRunner = new AgentComponentAdapter(agentComponent, {}, this.sessionComponent);
+      }
+    }
+    const registry = new NodeRegistry({
+      toolRegistry: toolComponent,
+      skillRegistry: skillComponent,
+      agentRunner,
+      sessionComponent: this.sessionComponent
+    });
+    registerDecoratorNodeType2(registry);
+    const engine = new WorkflowEngine(registry);
+    return engine.runWorkflow(definition, { ...options, input });
+  }
+  async onStop() {
+    componentLogger.info("[WorkflowComponent] Stopping and cleaning up resources...");
+    if (this.nodeRegistry) {
+      this.nodeRegistry = null;
+    }
+    if (this.workflowService) {
+      this.workflowService = null;
+      try {
+        const { closeDatabase } = await import("./roy-agent-core-wft9ra24.js");
+        closeDatabase();
+        componentLogger.info("[WorkflowComponent] SQLite database closed");
+      } catch (error) {
+        componentLogger.warn("[WorkflowComponent] Failed to close SQLite database:", error);
+      }
+    }
+    this._status = "stopped";
+    componentLogger.info("[WorkflowComponent] Cleanup completed");
+  }
+  async start() {
+    await super.start();
+    await this.initSqliteService();
+    await this.registerAskUserTool();
+  }
+  async registerAskUserTool() {
+    try {
+      const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
+      if (!toolComponent) {
+        componentLogger.warn("ToolComponent not available, cannot register ask_user tool");
+        return;
+      }
+      if (typeof toolComponent.register === "function") {
+        toolComponent.register(askUserTool);
+        componentLogger.info("ask_user tool registered to ToolComponent");
+      } else if (typeof toolComponent.registerMany === "function") {
+        toolComponent.registerMany([askUserTool]);
+        componentLogger.info("ask_user tool registered to ToolComponent");
+      } else {
+        componentLogger.warn("ToolComponent does not support tool registration");
+      }
+    } catch (error) {
+      componentLogger.warn("Failed to register ask_user tool:", error);
+    }
+  }
+  async initSqliteService() {
+    try {
+      const { getDatabase, initializeTables } = await import("./roy-agent-core-wft9ra24.js");
+      const { WorkflowRepository } = await import("./roy-agent-core-bcbqy27c.js");
+      const db = getDatabase();
+      initializeTables();
+      const workflowRepository = new WorkflowRepository(db);
+      const toolComponent = this.toolComponent || this._workflowEnv?.getComponent("tool");
+      const llmComponent = this.llmComponent || this._workflowEnv?.getComponent("llm");
+      const agentComponent = this._workflowEnv?.getComponent("agent");
+      const skillComponent = this.skillRegistry || this._workflowEnv?.getComponent("skill");
+      const sessionComponent = this._workflowEnv?.getComponent("session");
+      componentLogger.info(`initSqliteService - toolComponent: ${!!toolComponent}, llmComponent: ${!!llmComponent}, skillRegistry: ${!!skillComponent}, sessionComponent: ${!!sessionComponent}`);
+      this.createService({
+        workflowRepository,
+        toolComponent,
+        llmComponent,
+        env: this._workflowEnv,
+        skillRegistry: skillComponent,
+        sessionComponent
+      });
+      this.sessionComponent = sessionComponent;
+      await this.registerAskUserTool();
+      componentLogger.info("SQLite WorkflowService initialized successfully");
+    } catch (error) {
+      componentLogger.error("Failed to initialize SQLite WorkflowService:", error);
+      await this.createInMemoryService();
+    }
+  }
+  createInMemoryService() {
+    const workflows = new Map;
+    const workflowRepository = {
+      create: (wf) => {
+        const id = wf.id || `wf_${Date.now()}`;
+        const record = { ...wf, id, createdAt: new Date, updatedAt: new Date };
+        workflows.set(id, record);
+        return record;
+      },
+      getById: (id) => workflows.get(id) || null,
+      getByName: (name) => {
+        for (const wf of workflows.values()) {
+          if (wf.name === name)
+            return wf;
+        }
+        return null;
+      },
+      list: () => Array.from(workflows.values()),
+      update: (id, updates) => {
+        const wf = workflows.get(id);
+        if (!wf)
+          return null;
+        const updated = { ...wf, ...updates, updatedAt: new Date };
+        workflows.set(id, updated);
+        return updated;
+      },
+      delete: (id) => workflows.delete(id)
+    };
+    const sessionComponent = this._workflowEnv?.getComponent("session");
+    return this.createService({
+      workflowRepository,
+      sessionComponent
+    });
+  }
+  async stop() {
+    componentLogger.info("Stopping WorkflowComponent...");
+    this._status = "stopping";
+    this.workflowService = null;
+    this.nodeRegistry = null;
+    this._status = "stopped";
+    componentLogger.info("WorkflowComponent stopped");
+  }
+}
+
+export { WorkflowComponent };