@ai-setting/roy-agent-core 1.5.15-test → 1.5.16-test

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

@@ -0,0 +1,492 @@
+import {
+  envKeyToConfigKey,
+  toEnvKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+
+// 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";
+
+// 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;
+  }
+}
+
+// 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"] }
+  ]
+};
+
+// 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-fs0mn2jk.js

@@ -0,0 +1,52 @@
+import { createRequire } from "node:module";
+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 = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __toCommonJS, __export, __legacyDecorateClassTS, __esm, __require };

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

@@ -0,0 +1,171 @@
+// src/env/memory/built-in/record-memory.ts
+import { z } from "zod";
+var RecordMemorySchema = z.object({
+  scope: z.enum(["project", "global"]).describe("作用域: project/global"),
+  mode: z.enum(["append", "prepend", "overwrite", "delete"]).describe("模式: append(追加)/prepend(插入)/overwrite(覆盖)/delete(删除)"),
+  content: z.string().optional().describe("记忆内容"),
+  title: z.string().optional().describe("章节标题")
+});
+function createRecordMemoryTool(recordMemory, getMemoryPaths, getMemoryFile) {
+  return {
+    name: "record_memory",
+    description: buildDescription(getMemoryPaths, getMemoryFile),
+    parameters: RecordMemorySchema,
+    execute: async (args, _ctx) => {
+      const params = RecordMemorySchema.parse(args);
+      const startTime = Date.now();
+      try {
+        const result = await recordMemory({
+          scope: params.scope,
+          mode: params.mode,
+          content: params.content,
+          title: params.title
+        });
+        if (!result) {
+          return {
+            success: false,
+            output: "",
+            error: "未配置 memory 路径，无法记录记忆",
+            metadata: { execution_time_ms: Date.now() - startTime }
+          };
+        }
+        const actionMessages = {
+          created: "已创建记忆文件",
+          overwrite: "已覆盖记忆文件",
+          append: "已追加内容到记忆文件",
+          prepend: "已插入内容到记忆文件开头",
+          delete: "已删除记忆文件"
+        };
+        return {
+          success: true,
+          output: `${actionMessages[result.action]}: ${result.path}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            path: result.path,
+            action: result.action
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    }
+  };
+}
+function buildDescription(getMemoryPaths, getMemoryFile) {
+  const paths = getMemoryPaths();
+  const memoryFile = getMemoryFile();
+  const lines = [
+    `# Record Memory Tool`,
+    "",
+    `Record memory to file. Writes to the memory.md file in the specified scope.`,
+    "",
+    `## Modes`,
+    "",
+    "| Mode | Description |",
+    "|------|-------------|",
+    "| **append** | 追加内容到 ${memoryFile} 尾部 |",
+    "| **prepend** | 插入内容到 ${memoryFile} 开头 |",
+    "| **overwrite** | 覆盖 ${memoryFile} |",
+    "| **delete** | 删除 ${memoryFile} |",
+    "",
+    `## Parameters`,
+    "",
+    "- **scope** (required): 作用域 - project 或 global",
+    "- **mode** (required): 操作模式",
+    "- **content** (optional): 记忆内容",
+    "- **title** (optional): 章节标题",
+    "",
+    `## Memory Paths`,
+    ""
+  ];
+  if (paths.length === 0) {
+    lines.push("No memory paths configured.");
+  } else {
+    lines.push("Files will be written to:");
+    for (const p of paths) {
+      lines.push(`- **[${p.type}]** ${p.path}/${memoryFile}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/env/memory/built-in/recall-memory.ts
+import { z as z2 } from "zod";
+var RecallMemorySchema = z2.object({
+  scope: z2.enum(["project", "global"]).optional().describe("作用域（可选，不传则读取所有）")
+});
+function createRecallMemoryTool(recallMemory, getMemoryPaths, getMemoryFile) {
+  return {
+    name: "recall_memory",
+    description: buildDescription2(getMemoryPaths, getMemoryFile),
+    parameters: RecallMemorySchema,
+    execute: async (args, _ctx) => {
+      const params = RecallMemorySchema.parse(args);
+      const startTime = Date.now();
+      try {
+        const content = await recallMemory(params.scope);
+        if (!content) {
+          return {
+            success: true,
+            output: "(No memory files found)",
+            metadata: { execution_time_ms: Date.now() - startTime }
+          };
+        }
+        return {
+          success: true,
+          output: content,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    }
+  };
+}
+function buildDescription2(getMemoryPaths, getMemoryFile) {
+  const paths = getMemoryPaths();
+  const memoryFile = getMemoryFile();
+  const lines = [
+    `# Recall Memory Tool`,
+    "",
+    `Recall memory from memory files. Reads from the memory.md file in the specified scope.`,
+    "",
+    `## Parameters`,
+    "",
+    "- **scope** (optional): 作用域 - project 或 global（不传则读取所有）",
+    "",
+    `## Memory Files`,
+    ""
+  ];
+  if (paths.length === 0) {
+    lines.push("No memory paths configured.");
+  } else {
+    lines.push("Files will be read from:");
+    for (const p of paths) {
+      lines.push(`- **[${p.type}]** ${p.path}/${memoryFile}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/env/memory/built-in/index.ts
+function createMemoryTools(recordMemory, recallMemory, config) {
+  return [
+    createRecordMemoryTool(recordMemory, config.getMemoryPaths, config.getMemoryFile),
+    createRecallMemoryTool(recallMemory, config.getMemoryPaths, config.getMemoryFile)
+  ];
+}
+
+export { RecordMemorySchema, RecallMemorySchema, createMemoryTools };