@ai-setting/roy-agent-core 1.4.12 → 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/{env/workflow/service/index.js → shared/@ai-setting/roy-agent-core-yt8wdh2w.js}

@@ -1,54 +1,3 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
 // packages/core/src/env/workflow/service/workflow-service.ts
 class WorkflowService {
   workflowRepository;
@@ -254,9 +203,4 @@ function getWorkflowService() {
 function registerWorkflowService(service) {
   WorkflowServiceRegistry.getInstance().register(service);
 }
-export {
-  registerWorkflowService,
-  getWorkflowService,
-  WorkflowServiceRegistry,
-  WorkflowService
-};
+export { WorkflowService, WorkflowServiceRegistry, getWorkflowService, registerWorkflowService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.4.12",
+  "version": "1.4.14",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",
@@ -72,7 +72,8 @@
     "url": "https://github.com/ai-setting/roy-agent/issues"
   },
   "scripts": {
-    "build": "bun run bunup",
+    "build": "bunup -- --entry src/index.ts --entry 'src/**/index.ts' --source-base src",
+    "build:main": "bunup -- --entry src/index.ts --source-base src",
     "clean": "rm -rf dist",
     "typecheck": "npx tsc --noEmit --skipLibCheck --project tsconfig.json"
   }