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

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

@@ -0,0 +1,206 @@
+// src/env/workflow/service/workflow-service.ts
+class WorkflowService {
+  workflowRepository;
+  engineFactory;
+  sessionComponent;
+  constructor(workflowRepository, engineFactory, sessionComponent) {
+    this.workflowRepository = workflowRepository;
+    this.engineFactory = engineFactory;
+    this.sessionComponent = sessionComponent;
+  }
+  async createWorkflow(definition, options) {
+    const existing = this.workflowRepository.getByName(definition.name);
+    if (existing) {
+      if (options?.force !== true) {
+        throw new Error(`Workflow already exists: ${definition.name}`);
+      }
+      return this.workflowRepository.update(existing.id, {
+        name: definition.name,
+        version: definition.version,
+        description: definition.description || existing.description,
+        definition,
+        config: definition.config || {},
+        metadata: {
+          ...options.metadata || definition.metadata || existing.metadata || {},
+          taskId: options.taskId || definition.metadata?.taskId || existing.metadata?.taskId
+        },
+        tags: options.tags || definition.metadata?.tags || []
+      });
+    }
+    const workflow = {
+      name: definition.name,
+      version: definition.version,
+      description: definition.description,
+      definition,
+      config: definition.config || {},
+      metadata: {
+        ...options?.metadata || definition.metadata || {},
+        taskId: options?.taskId || definition.metadata?.taskId
+      },
+      tags: options?.tags || definition.metadata?.tags || []
+    };
+    return this.workflowRepository.create(workflow);
+  }
+  getWorkflow(idOrName) {
+    let workflow = this.workflowRepository.getById(idOrName);
+    if (workflow)
+      return workflow;
+    return this.workflowRepository.getByName(idOrName);
+  }
+  getWorkflowById(id) {
+    return this.workflowRepository.getById(id);
+  }
+  getWorkflowByName(name) {
+    return this.workflowRepository.getByName(name);
+  }
+  listWorkflows(options) {
+    return this.workflowRepository.list(options);
+  }
+  async updateWorkflow(idOrName, updates, options) {
+    let workflow = this.workflowRepository.getByName(idOrName);
+    if (!workflow) {
+      workflow = this.workflowRepository.getById(idOrName);
+    }
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${idOrName}`);
+    }
+    const updateData = {
+      ...updates
+    };
+    if (options?.tags !== undefined) {
+      updateData.tags = options.tags;
+    }
+    const updated = this.workflowRepository.update(workflow.id, updateData);
+    if (!updated) {
+      throw new Error(`Failed to update workflow: ${idOrName}`);
+    }
+    return updated;
+  }
+  async deleteWorkflow(idOrName) {
+    let workflow = this.workflowRepository.getByName(idOrName);
+    if (!workflow) {
+      workflow = this.workflowRepository.getById(idOrName);
+    }
+    if (!workflow) {
+      return false;
+    }
+    return this.workflowRepository.delete(workflow.id);
+  }
+  async runWorkflow(idOrNameOrDefinition, input, options) {
+    let workflow = null;
+    let definition = null;
+    if (typeof idOrNameOrDefinition === "string") {
+      workflow = this.getWorkflow(idOrNameOrDefinition);
+      if (!workflow) {
+        throw new Error(`Workflow not found: ${idOrNameOrDefinition}`);
+      }
+      definition = workflow.definition;
+    } else {
+      definition = idOrNameOrDefinition;
+      workflow = this.getWorkflowByName(definition.name);
+      if (!workflow) {
+        workflow = {
+          id: `wf_inline_${definition.name}`,
+          name: definition.name,
+          version: definition.version,
+          description: definition.description,
+          definition,
+          config: definition.config || {},
+          metadata: definition.metadata || {},
+          tags: definition.metadata?.tags || [],
+          createdAt: new Date,
+          updatedAt: new Date
+        };
+      }
+    }
+    const engine = this.engineFactory(workflow, {
+      ...options,
+      input
+    });
+    const result = await engine.runWorkflow(workflow, {
+      ...options,
+      input
+    });
+    return {
+      ...result,
+      runId: result.runId || result.sessionId || "",
+      sessionId: result.sessionId || result.runId || ""
+    };
+  }
+  async runWorkflowByName(name, input, options) {
+    const workflow = this.getWorkflowByName(name);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${name}`);
+    }
+    return this.runWorkflow(name, input, options);
+  }
+  async stopRun(sessionId, reason) {
+    const session = await this.sessionComponent?.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const metadata = session.metadata;
+    if (metadata.type !== "workflow") {
+      throw new Error(`Session is not a workflow session: ${sessionId}`);
+    }
+    const workflow = this.getWorkflowByName(metadata.workflowName);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${metadata.workflowName}`);
+    }
+    const engine = this.engineFactory(workflow);
+    await engine.stop(sessionId, reason);
+  }
+  async getSession(sessionId) {
+    if (!this.sessionComponent) {
+      return null;
+    }
+    const session = await this.sessionComponent.get(sessionId);
+    return session ?? null;
+  }
+  async listSessions(options) {
+    if (!this.sessionComponent?.list) {
+      return [];
+    }
+    return this.sessionComponent.list(options);
+  }
+  async getSessionMessages(sessionId) {
+    if (!this.sessionComponent) {
+      return [];
+    }
+    return this.sessionComponent.getMessages(sessionId);
+  }
+}
+// src/env/workflow/service/registry.ts
+class WorkflowServiceRegistry {
+  static instance;
+  service = null;
+  constructor() {}
+  static getInstance() {
+    if (!WorkflowServiceRegistry.instance) {
+      WorkflowServiceRegistry.instance = new WorkflowServiceRegistry;
+    }
+    return WorkflowServiceRegistry.instance;
+  }
+  register(service) {
+    this.service = service;
+  }
+  get() {
+    if (!this.service) {
+      throw new Error("WorkflowService is not registered. Call register() first.");
+    }
+    return this.service;
+  }
+  isRegistered() {
+    return this.service !== null;
+  }
+  reset() {
+    this.service = null;
+  }
+}
+function getWorkflowService() {
+  return WorkflowServiceRegistry.getInstance().get();
+}
+function registerWorkflowService(service) {
+  WorkflowServiceRegistry.getInstance().register(service);
+}
+export { WorkflowService, WorkflowServiceRegistry, getWorkflowService, registerWorkflowService };

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

@@ -0,0 +1,377 @@
+import {
+  createSkillTool
+} from "./roy-agent-core-psvxt4c9.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/skill/skill-component.ts
+init_logger();
+
+// src/env/skill/scanner.ts
+init_logger();
+import fs2 from "fs/promises";
+import path2 from "path";
+import { glob } from "glob";
+
+// src/env/skill/parser.ts
+init_logger();
+import fs from "fs/promises";
+var logger = createLogger("skill-parser");
+function parseFrontmatter(text) {
+  const result = {};
+  const lines = text.split(`
+`);
+  for (const line of lines) {
+    const match = line.match(/^(\w+):\s*"?(.+?)"?\s*$/);
+    if (match) {
+      const key = match[1];
+      let value = match[2];
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1);
+      }
+      result[key] = value;
+    }
+  }
+  return result;
+}
+async function parseSkillFile(filePath, source) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
+    if (!frontmatterMatch) {
+      logger.warn(`[SkillParser] Missing frontmatter in: ${filePath}`);
+      return null;
+    }
+    const frontmatter = parseFrontmatter(frontmatterMatch[1]);
+    const name = frontmatter.name;
+    const description = frontmatter.description;
+    if (!name) {
+      logger.warn(`[SkillParser] Missing name in frontmatter: ${filePath}`);
+      return null;
+    }
+    if (!description) {
+      logger.warn(`[SkillParser] Missing description in frontmatter: ${filePath}`);
+      return null;
+    }
+    const actualContent = content.replace(/^---\n[\s\S]*?\n---\n?/, "");
+    return {
+      name,
+      description,
+      filePath,
+      content: actualContent,
+      source,
+      loadedAt: Date.now()
+    };
+  } catch (error) {
+    logger.error(`[SkillParser] Failed to parse file: ${filePath}`, error);
+    return null;
+  }
+}
+
+// src/env/skill/config.ts
+import path from "path";
+import os from "os";
+var DEFAULT_SKILL_CONFIG = {
+  skillPaths: [
+    {
+      type: "user",
+      path: path.join(os.homedir(), ".config", "roy-agent", "skills")
+    },
+    {
+      type: "project",
+      path: ".roy/skills"
+    }
+  ],
+  recursive: true,
+  cacheEnabled: true
+};
+var SOURCE_PRIORITY = {
+  "built-in": 0,
+  user: 1,
+  project: 2
+};
+function getSourcePriority(source) {
+  return SOURCE_PRIORITY[source] ?? 0;
+}
+
+// src/env/skill/scanner.ts
+var logger2 = createLogger("skill-scanner");
+function expandPath(inputPath) {
+  if (inputPath.startsWith("~/")) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    return path2.join(home, inputPath.slice(2));
+  }
+  return path2.resolve(inputPath);
+}
+async function pathExists(p) {
+  try {
+    await fs2.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+class SkillScanner {
+  config;
+  skillsMap;
+  constructor(config) {
+    this.config = config;
+    this.skillsMap = new Map;
+  }
+  async scan() {
+    this.skillsMap.clear();
+    for (const skillPath of this.config.skillPaths) {
+      await this.scanPath(skillPath);
+    }
+    return this.skillsMap;
+  }
+  async scanPath(skillPath) {
+    const expandedPath = expandPath(skillPath.path);
+    if (!await pathExists(expandedPath)) {
+      logger2.info(`[SkillScanner] Path not found, skipping: ${expandedPath}`);
+      return;
+    }
+    logger2.info(`[SkillScanner] Scanning: ${expandedPath}`);
+    const sep = "/";
+    const basePattern = expandedPath.replace(/\\/g, "/");
+    const pattern = this.config.recursive ? `${basePattern}${sep}**${sep}SKILL.md` : `${basePattern}${sep}SKILL.md`;
+    const files = await glob(pattern, {
+      absolute: true,
+      ignore: ["**/node_modules/**"]
+    });
+    logger2.info(`[SkillScanner] Found ${files.length} SKILL.md files`);
+    for (const filePath of files) {
+      await this.processFile(filePath, skillPath.type);
+    }
+  }
+  async processFile(filePath, source) {
+    const entry = await parseSkillFile(filePath, source);
+    if (!entry) {
+      return;
+    }
+    const existing = this.skillsMap.get(entry.name);
+    if (!existing || getSourcePriority(source) > getSourcePriority(existing.source)) {
+      this.skillsMap.set(entry.name, entry);
+      logger2.debug(`[SkillScanner] Loaded skill: ${entry.name} (${source})`);
+    }
+  }
+  getSkills() {
+    return this.skillsMap;
+  }
+}
+
+// src/env/skill/skill-config-registration.ts
+import path3 from "path";
+import os2 from "os";
+var SKILL_DEFAULTS = {
+  "skill.skillPaths": [
+    { type: "user", path: path3.join(os2.homedir(), ".config", "roy-agent", "skills") },
+    { type: "project", path: ".roy/skills" }
+  ],
+  "skill.recursive": true,
+  "skill.cacheEnabled": true
+};
+var SKILL_CONFIG_REGISTRATION = {
+  name: "skill",
+  sources: [
+    { type: "env", envPrefix: "SKILL", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "skill.skillPaths", sources: ["env", "file"] },
+    { key: "skill.recursive", sources: ["env", "file"] },
+    { key: "skill.cacheEnabled", sources: ["env", "file"] }
+  ]
+};
+
+// src/env/skill/skill-component.ts
+var logger3 = createLogger("skill");
+
+class SkillComponent extends BaseComponent {
+  name = "skill";
+  version = "1.0.0";
+  config;
+  toolComponent;
+  scanner;
+  skillsMap = new Map;
+  configComponent;
+  configWatcher;
+  async init(config) {
+    await super.init(config);
+    const options = config?.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for SkillComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    this.scanner = new SkillScanner(this.config);
+    logger3.info("[SkillComponent] Initialized");
+  }
+  async registerConfig(options) {
+    const configComponent = this.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix ?? "SKILL";
+    configComponent.registerComponent(SKILL_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("skill");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "skill");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(SKILL_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("skill.recursive") ?? true;
+    const cacheEnabled = configComponent.get("skill.cacheEnabled") ?? true;
+    const skillPathsConfig = configComponent.get("skill.skillPaths");
+    let skillPaths = [];
+    if (Array.isArray(skillPathsConfig)) {
+      skillPaths = skillPathsConfig;
+    } else if (typeof skillPathsConfig === "string") {
+      try {
+        skillPaths = JSON.parse(skillPathsConfig);
+      } catch {
+        skillPaths = DEFAULT_SKILL_CONFIG.skillPaths;
+      }
+    }
+    if (skillPaths.length === 0) {
+      skillPaths = DEFAULT_SKILL_CONFIG.skillPaths;
+    }
+    this.config = {
+      skillPaths,
+      recursive,
+      cacheEnabled
+    };
+  }
+  flattenConfig(obj, prefix = "skill") {
+    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("skill.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    logger3.info(`[SkillComponent] Config changed: ${event.key}`, {
+      oldValue: event.oldValue,
+      newValue: event.newValue
+    });
+    if (this.configComponent) {
+      this.buildConfig(this.configComponent);
+    }
+  }
+  async start() {
+    await super.start();
+    this.toolComponent = this.env?.getComponent("tool");
+    if (!this.toolComponent) {
+      logger3.warn("[SkillComponent] ToolComponent not found, skipping tool registration");
+      return;
+    }
+    await this.scanSkills();
+    await this.registerTool();
+    this.setStatus("running");
+    logger3.info(`[SkillComponent] Started with ${this.skillsMap.size} skills`);
+  }
+  async stop() {
+    if (this.configWatcher) {
+      this.configWatcher();
+      this.configWatcher = undefined;
+    }
+    if (this.toolComponent) {
+      this.toolComponent.unregister("skill");
+    }
+    await super.stop();
+    logger3.info("[SkillComponent] Stopped");
+  }
+  getSkill(name) {
+    return this.skillsMap.get(name);
+  }
+  getSkillList() {
+    return Array.from(this.skillsMap.values()).map((entry) => ({
+      name: entry.name,
+      description: entry.description,
+      source: entry.source
+    }));
+  }
+  hasSkill(name) {
+    return this.skillsMap.has(name);
+  }
+  getAllSkills() {
+    return Array.from(this.skillsMap.values());
+  }
+  async scanSkills() {
+    this.scanner = new SkillScanner(this.config);
+    this.skillsMap = await this.scanner.scan();
+    logger3.info(`[SkillComponent] Scanned ${this.skillsMap.size} skills`);
+  }
+  async reload() {
+    if (!this.toolComponent) {
+      throw new Error("ToolComponent not available");
+    }
+    logger3.info("[SkillComponent] Reloading skills...");
+    this.toolComponent.unregister("skill");
+    await this.scanSkills();
+    await this.registerTool();
+    logger3.info(`[SkillComponent] Reloaded ${this.skillsMap.size} skills`);
+  }
+  async registerTool() {
+    if (!this.toolComponent)
+      return;
+    const tool = createSkillTool(() => this.getSkillList(), (name) => this.getSkill(name));
+    this.toolComponent.register(tool);
+    logger3.info("[SkillComponent] Registered SkillTool");
+  }
+}
+export { parseFrontmatter, parseSkillFile, DEFAULT_SKILL_CONFIG, SOURCE_PRIORITY, getSourcePriority, SkillScanner, SkillComponent };