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

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

@@ -0,0 +1,492 @@
+import {
+  envKeyToConfigKey,
+  toEnvKey
+} from "./roy-agent-core-jv3b7v9w.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-m2x48hw6.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-yn761yve.js";
+
+// packages/core/src/env/commands/commands-component.ts
+import path2 from "path";
+import os from "os";
+init_logger();
+import * as fs2 from "fs/promises";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// packages/core/src/env/commands/parser.ts
+init_logger();
+import fs from "fs/promises";
+import path from "path";
+var logger = createLogger("commands-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 parseMetaFile(filePath, source) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
+    if (!frontmatterMatch) {
+      logger.warn(`[Parser] Missing frontmatter in: ${filePath}`);
+      return null;
+    }
+    const frontmatter = parseFrontmatter(frontmatterMatch[1]);
+    const name = frontmatter.name;
+    const description = frontmatter.description;
+    if (!name) {
+      logger.warn(`[Parser] Missing name in frontmatter: ${filePath}`);
+      return null;
+    }
+    if (!description) {
+      logger.warn(`[Parser] Missing description in frontmatter: ${filePath}`);
+      return null;
+    }
+    return {
+      name,
+      description,
+      tips: frontmatter.tips,
+      filePath,
+      source
+    };
+  } catch (error) {
+    logger.error(`[Parser] Failed to parse file: ${filePath}`, error);
+    return null;
+  }
+}
+
+// packages/core/src/env/commands/commands-config-registration.ts
+var COMMANDS_CONFIG_REGISTRATION = {
+  name: "command",
+  sources: [
+    { type: "env", envPrefix: "COMMAND", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "command.userCommandsDir", sources: ["env", "file"] },
+    { key: "command.projectCommandsDir", sources: ["env", "file"] },
+    { key: "command.cacheDir", sources: ["env", "file"] }
+  ]
+};
+
+// packages/core/src/env/commands/commands-component.ts
+var execAsync = promisify(exec);
+var logger2 = createLogger("commands");
+var DEFAULT_USER_DIR = ".roy-agent/commands";
+var DEFAULT_PROJECT_DIR = ".roy/commands";
+var DEFAULT_CACHE_DIR = ".cache/roy-agent/commands";
+var DESCRIPTIONS_FILE = "descriptions.json";
+var CONFIG_KEYS = [
+  "command.userCommandsDir",
+  "command.projectCommandsDir",
+  "command.cacheDir"
+];
+
+class CommandsComponent extends BaseComponent {
+  name = "commands";
+  version = "2.0.0";
+  config;
+  configComponent;
+  userCommandsDir = "";
+  projectCommandsDir = "";
+  descriptionCache = new Map;
+  descriptionCacheFile = "";
+  constructor() {
+    super();
+    this.initDefaultDirs();
+  }
+  initDefaultDirs() {
+    const homeDir = os.homedir();
+    this.userCommandsDir = path2.join(homeDir, DEFAULT_USER_DIR);
+    this.projectCommandsDir = DEFAULT_PROJECT_DIR;
+    this.descriptionCacheFile = path2.join(homeDir, DEFAULT_CACHE_DIR, DESCRIPTIONS_FILE);
+  }
+  async init(config) {
+    await super.init(config);
+    const options = config?.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for CommandsComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    await fs2.mkdir(this.userCommandsDir, { recursive: true });
+    await this.loadDescriptionCache();
+    logger2.info(`CommandsComponent initialized: user=${this.userCommandsDir}, project=${this.projectCommandsDir}`);
+  }
+  async registerConfig(options) {
+    const configComponent = this.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    configComponent.registerComponent(COMMANDS_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    await configComponent.load("command");
+    const prefix = envPrefix !== undefined ? envPrefix : "COMMAND";
+    for (const key of CONFIG_KEYS) {
+      const envKey = toEnvKey(key, prefix);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    const loadedKeys = new Set(CONFIG_KEYS);
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "command");
+      if (!configKey)
+        continue;
+      if (loadedKeys.has(configKey))
+        continue;
+      loadedKeys.add(configKey);
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        if (value !== undefined) {
+          await configComponent.set(key, value);
+        }
+      }
+    }
+    const homeDir = os.homedir();
+    const defaultDirs = {
+      "command.userCommandsDir": path2.join(homeDir, DEFAULT_USER_DIR),
+      "command.projectCommandsDir": DEFAULT_PROJECT_DIR,
+      "command.cacheDir": path2.join(homeDir, DEFAULT_CACHE_DIR)
+    };
+    for (const [key, value] of Object.entries(defaultDirs)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.applyConfig(configComponent);
+  }
+  flattenConfig(config) {
+    const result = {};
+    if (config.userCommandsDir !== undefined) {
+      result["command.userCommandsDir"] = config.userCommandsDir;
+    }
+    if (config.projectCommandsDir !== undefined) {
+      result["command.projectCommandsDir"] = config.projectCommandsDir;
+    }
+    if (config.cacheDir !== undefined) {
+      result["command.cacheDir"] = config.cacheDir;
+    }
+    return result;
+  }
+  applyConfig(configComponent) {
+    const userDir = configComponent.get("command.userCommandsDir");
+    const projectDir = configComponent.get("command.projectCommandsDir");
+    const cacheDir = configComponent.get("command.cacheDir");
+    this.userCommandsDir = userDir || path2.join(os.homedir(), DEFAULT_USER_DIR);
+    this.projectCommandsDir = projectDir || DEFAULT_PROJECT_DIR;
+    this.descriptionCacheFile = path2.join(cacheDir || path2.join(os.homedir(), DEFAULT_CACHE_DIR), DESCRIPTIONS_FILE);
+    this.config = {
+      userCommandsDir: this.userCommandsDir,
+      projectCommandsDir: this.projectCommandsDir,
+      cacheDir
+    };
+  }
+  async start() {
+    await super.start();
+    logger2.debug("CommandsComponent started");
+  }
+  async stop() {
+    await this.saveDescriptionCache();
+    await super.stop();
+    logger2.debug("CommandsComponent stopped");
+  }
+  async getCommandDirs() {
+    return {
+      user: this.userCommandsDir,
+      project: this.projectCommandsDir
+    };
+  }
+  async discover(options) {
+    const commands = [];
+    let userCount = 0;
+    let projectCount = 0;
+    try {
+      const projectCommands = await this.scanDir(this.projectCommandsDir, "project", options?.pattern);
+      commands.push(...projectCommands);
+      projectCount = projectCommands.length;
+    } catch (error) {
+      logger2.debug(`Failed to scan project dir: ${error}`);
+    }
+    try {
+      const userCommands = await this.scanDir(this.userCommandsDir, "user", options?.pattern);
+      for (const cmd of userCommands) {
+        const exists = commands.find((c) => c.name === cmd.name);
+        if (!exists) {
+          commands.push(cmd);
+          userCount++;
+        }
+      }
+    } catch (error) {
+      logger2.debug(`Failed to scan user dir: ${error}`);
+    }
+    commands.sort((a, b) => a.name.localeCompare(b.name));
+    return {
+      commands,
+      stats: { userCount, projectCount }
+    };
+  }
+  async add(options) {
+    const { name, target, source = "user", description, tips } = options;
+    const dir = source === "user" ? this.userCommandsDir : this.projectCommandsDir;
+    const targetPath = path2.resolve(target);
+    await fs2.mkdir(dir, { recursive: true });
+    const commandPath = path2.join(dir, name);
+    try {
+      await fs2.access(commandPath);
+      throw new Error(`Command '${name}' already exists`);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    await fs2.symlink(targetPath, commandPath);
+    logger2.info(`Added command '${name}' -> ${targetPath} (${source})`);
+    const commandDir = path2.join(dir, name);
+    await this.createCommandMeta(commandDir, {
+      name,
+      target: targetPath,
+      description: description || `Command: ${name}`,
+      tips,
+      source
+    });
+  }
+  async createCommandMeta(commandDir, options) {
+    const parentDir = path2.dirname(commandDir);
+    const metaPath = path2.join(parentDir, `${options.name}.meta.md`);
+    const tipsContent = options.tips ? `
+tips: "${options.tips}"` : "";
+    const content = `---
+name: ${options.name}
+description: ${options.description}${tipsContent}
+source: ${options.source}
+---
+
+# ${options.name} Command
+
+## Target
+\`${options.target}\`
+
+## 功能
+${options.description}
+
+## 探索提示
+Run \`${options.name} --help\` to explore full capabilities.
+`;
+    await fs2.writeFile(metaPath, content, "utf-8");
+    logger2.info(`[CommandsComponent] Created meta.md for '${options.name}'`);
+  }
+  async getCommandsMeta() {
+    const metaList = [];
+    try {
+      const entries = await fs2.readdir(this.userCommandsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".meta.md")) {
+          const metaPath = path2.join(this.userCommandsDir, entry.name);
+          const meta = await parseMetaFile(metaPath, "user");
+          if (meta) {
+            metaList.push(meta);
+          }
+        }
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        logger2.debug(`Failed to scan user commands dir: ${error}`);
+      }
+    }
+    try {
+      const entries = await fs2.readdir(this.projectCommandsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".meta.md")) {
+          const metaPath = path2.join(this.projectCommandsDir, entry.name);
+          const meta = await parseMetaFile(metaPath, "project");
+          if (meta) {
+            metaList.push(meta);
+          }
+        }
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        logger2.debug(`Failed to scan project commands dir: ${error}`);
+      }
+    }
+    return metaList;
+  }
+  async remove(options) {
+    const { name, source } = options;
+    const dirsToCheck = source ? [source === "user" ? this.userCommandsDir : this.projectCommandsDir] : [this.userCommandsDir, this.projectCommandsDir];
+    for (const dir of dirsToCheck) {
+      const commandPath = path2.join(dir, name);
+      try {
+        await fs2.unlink(commandPath);
+        logger2.info(`Removed command '${name}' from ${dir}`);
+        return;
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+    }
+    throw new Error(`Command '${name}' not found`);
+  }
+  async getInfo(name) {
+    const dirsToCheck = [this.projectCommandsDir, this.userCommandsDir];
+    for (const dir of dirsToCheck) {
+      const commandPath = path2.join(dir, name);
+      try {
+        const stat = await fs2.lstat(commandPath);
+        const realPath = stat.isSymbolicLink() ? await fs2.readlink(commandPath) : commandPath;
+        const cmdSource = dir === this.projectCommandsDir ? "project" : "user";
+        const shortDescription = await this.getDescription(realPath);
+        return {
+          name,
+          path: realPath,
+          source: cmdSource,
+          shortDescription
+        };
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+    }
+    return null;
+  }
+  async exec(options) {
+    const { name, args = [], cwd } = options;
+    const info = await this.getInfo(name);
+    if (!info) {
+      return {
+        stdout: "",
+        stderr: `Command '${name}' not found`,
+        exitCode: 127,
+        success: false
+      };
+    }
+    const cmd = `${info.path} ${args.join(" ")}`;
+    try {
+      const { stdout, stderr } = await execAsync(cmd, {
+        cwd: cwd || process.cwd(),
+        timeout: 30000
+      });
+      return {
+        stdout,
+        stderr,
+        exitCode: 0,
+        success: true
+      };
+    } catch (error) {
+      return {
+        stdout: error.stdout || "",
+        stderr: error.stderr || error.message,
+        exitCode: error.code || 1,
+        success: false
+      };
+    }
+  }
+  async scanDir(dir, source, pattern) {
+    const commands = [];
+    try {
+      const entries = await fs2.readdir(dir);
+      for (const entry of entries) {
+        if (entry.startsWith("."))
+          continue;
+        if (pattern && !this.matchPattern(entry, pattern))
+          continue;
+        const fullPath = path2.join(dir, entry);
+        try {
+          const stat = await fs2.lstat(fullPath);
+          if (!stat.isSymbolicLink() && !stat.isFile())
+            continue;
+          if (stat.isFile()) {
+            try {
+              await fs2.access(fullPath, fs2.constants.X_OK);
+            } catch {
+              continue;
+            }
+          }
+          const realPath = stat.isSymbolicLink() ? await fs2.readlink(fullPath) : fullPath;
+          const shortDescription = await this.getDescription(realPath);
+          commands.push({
+            name: entry,
+            path: realPath,
+            source,
+            shortDescription
+          });
+        } catch (error) {
+          logger2.debug(`Failed to stat ${fullPath}: ${error}`);
+        }
+      }
+    } catch (error) {
+      logger2.debug(`Failed to scan dir ${dir}: ${error}`);
+    }
+    return commands;
+  }
+  matchPattern(name, pattern) {
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
+    return regex.test(name);
+  }
+  async getDescription(commandPath) {
+    const cached = this.descriptionCache.get(commandPath);
+    if (cached !== undefined)
+      return cached;
+    try {
+      const { stdout } = await execAsync(`${commandPath} --help 2>/dev/null | head -1`, {
+        timeout: 2000
+      });
+      const description = stdout.trim().split(`
+`)[0] || "";
+      this.descriptionCache.set(commandPath, description);
+      return description;
+    } catch {
+      return "";
+    }
+  }
+  async loadDescriptionCache() {
+    try {
+      const content = await fs2.readFile(this.descriptionCacheFile, "utf-8");
+      const data = JSON.parse(content);
+      this.descriptionCache = new Map(Object.entries(data));
+    } catch {}
+  }
+  async saveDescriptionCache() {
+    try {
+      await fs2.mkdir(path2.dirname(this.descriptionCacheFile), { recursive: true });
+      const data = Object.fromEntries(this.descriptionCache);
+      await fs2.writeFile(this.descriptionCacheFile, JSON.stringify(data, null, 2));
+    } catch (error) {
+      logger2.debug(`Failed to save description cache: ${error}`);
+    }
+  }
+}
+export { CommandsComponent };

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

@@ -0,0 +1,206 @@
+// packages/core/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);
+  }
+}
+// packages/core/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 };