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

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

@@ -1,377 +0,0 @@
-import {
-  createSkillTool
-} from "./roy-agent-core-psvxt4c9.js";
-import {
-  envKeyToConfigKey
-} 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/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 };

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

@@ -1,172 +0,0 @@
-import {
-  createLogger,
-  getMaxOutput,
-  init_logger,
-  simplifyFilePath
-} from "./roy-agent-core-44hnfb02.js";
-import {
-  getTracerProvider,
-  init_tracer_provider
-} from "./roy-agent-core-xs5rsgat.js";
-import {
-  __esm
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/log-trace/decorator.ts
-function Traced(options) {
-  return function(target, propertyKey, descriptor) {
-    const originalFn = descriptor.value;
-    const spanName = options?.name || propertyKey;
-    descriptor.value = wrapFunction(originalFn, spanName, {
-      recordParams: options?.recordParams ?? true,
-      recordResult: options?.recordResult ?? false,
-      recordError: options?.recordError ?? true,
-      log: options?.log ?? false,
-      maxLogSize: options?.maxLogSize,
-      paramFilter: options?.paramFilter
-    });
-    return descriptor;
-  };
-}
-function TracedAs(name, options) {
-  return Traced({ name, ...options });
-}
-function TracedLightweight(options) {
-  return Traced({ recordParams: false, recordResult: false, log: options?.log ?? false, maxLogSize: options?.maxLogSize });
-}
-function wrapFunction(fn, name, options) {
-  const shouldLog = options?.log ?? false;
-  const getMaxLogSize = () => {
-    if (options?.maxLogSize !== undefined) {
-      return options.maxLogSize;
-    }
-    const configMaxOutput = getMaxOutput();
-    return configMaxOutput !== undefined ? configMaxOutput : 500;
-  };
-  const truncate = (obj) => {
-    if (obj === undefined)
-      return;
-    if (obj === null)
-      return null;
-    const maxLogSize = getMaxLogSize();
-    let str;
-    try {
-      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
-    } catch (e) {
-      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
-    }
-    if (maxLogSize > 0 && str.length > maxLogSize) {
-      return str.slice(0, maxLogSize) + " [TRUNCATED]";
-    }
-    try {
-      return JSON.parse(str);
-    } catch {
-      return str;
-    }
-  };
-  const truncateString = (obj) => {
-    if (obj === undefined)
-      return "undefined";
-    if (obj === null)
-      return "null";
-    const maxLogSize = getMaxLogSize();
-    let str;
-    try {
-      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
-    } catch (e) {
-      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
-    }
-    return maxLogSize > 0 && str.length > maxLogSize ? str.slice(0, maxLogSize) + " [TRUNCATED]" : str;
-  };
-  const TRACE_LOG_PREFIX = "[TRACE]";
-  const getCallerLocation = () => {
-    const originalLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 15;
-    const err = new Error;
-    Error.captureStackTrace(err, getCallerLocation);
-    const stack = err.stack?.split(`
-`) || [];
-    Error.stackTraceLimit = originalLimit;
-    for (let i = 1;i < stack.length; i++) {
-      const line = stack[i];
-      if (line.includes("decorator.ts") || line.includes("decorator.js") || line.includes("logFn") || line.includes("getCallerLocation"))
-        continue;
-      const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
-      if (match) {
-        const filePath = match[1];
-        if (!filePath || filePath === "native")
-          continue;
-        const relativePath = simplifyFilePath(filePath);
-        return `${relativePath}:${match[2]}`;
-      }
-    }
-    return "";
-  };
-  const logFn = (event, argsOrData, callerLocation) => {
-    if (!shouldLog)
-      return;
-    const logger = createLogger("traced:" + name);
-    const tag = event === "enter" ? ">>>" : event === "quit" ? "<<<" : "!!!";
-    const prefix = `${TRACE_LOG_PREFIX} ${tag} ${name}`;
-    const originalFnLocation = callerLocation || getCallerLocation();
-    const logMessage = (msg, data) => {
-      if (data !== undefined) {
-        logger.info(`${prefix} ${msg}: ${truncateString(data)}`, { callerLocation: originalFnLocation });
-      } else {
-        logger.info(`${prefix} ${msg}`, { callerLocation: originalFnLocation });
-      }
-    };
-    if (event === "enter") {
-      logMessage("enter", argsOrData);
-    } else if (event === "quit") {
-      logMessage("quit", options?.recordResult ? argsOrData : undefined);
-    } else {
-      logMessage("error", argsOrData);
-    }
-  };
-  return function(...args) {
-    const tracer = getTracerProvider().getTracer("roy-tracer");
-    const attributes = {};
-    if (options?.recordParams !== false) {
-      if (options?.paramFilter) {
-        attributes["params"] = truncate(options.paramFilter(args));
-      } else {
-        attributes["params"] = truncate(args);
-      }
-    }
-    const callerLocation = getCallerLocation();
-    logFn("enter", args, callerLocation);
-    const span = tracer.startSpan(name, { attributes });
-    try {
-      const result = fn.call(this, ...args);
-      if (result && typeof result === "object" && typeof result.then === "function") {
-        return result.then((resolved) => {
-          span.setAttribute("result", JSON.stringify(truncate(resolved)));
-          span.end(resolved);
-          logFn("quit", options?.recordResult ? resolved : undefined, callerLocation);
-          return resolved;
-        }, (rejected) => {
-          span.setAttribute("error", String(rejected));
-          span.end(undefined, rejected instanceof Error ? rejected : new Error(String(rejected)));
-          logFn("error", rejected.message, callerLocation);
-          throw rejected;
-        });
-      }
-      span.setAttribute("result", JSON.stringify(truncate(result)));
-      span.end(result);
-      logFn("quit", options?.recordResult ? result : undefined, callerLocation);
-      return result;
-    } catch (error) {
-      span.setAttribute("error", String(error));
-      span.end(undefined, error instanceof Error ? error : new Error(String(error)));
-      logFn("error", error.message, callerLocation);
-      throw error;
-    }
-  };
-}
-var init_decorator = __esm(() => {
-  init_tracer_provider();
-  init_logger();
-});
-
-export { Traced, TracedAs, TracedLightweight, wrapFunction, init_decorator };

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

@@ -1,103 +0,0 @@
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-44hnfb02.js";
-import {
-  __require
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/workflow/storage/sqlite.ts
-init_logger();
-import { join } from "path";
-var logger = createLogger("workflow:sqlite");
-function getDatabaseClass() {
-  if (typeof Bun !== "undefined") {
-    const { Database } = __require("bun:sqlite");
-    return Database;
-  } else {
-    return __require("better-sqlite3");
-  }
-}
-function createCompatibleDatabase(path) {
-  const Database = getDatabaseClass();
-  const db = new Database(path);
-  if (typeof db.run !== "function") {
-    db.run = function(sql, ...params) {
-      if (params.length > 0) {
-        return this.prepare(sql).run(...params);
-      } else {
-        return this.exec(sql);
-      }
-    };
-  }
-  return db;
-}
-function getDefaultDataDir() {
-  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-  return join(home, ".local", "share", "roy-agent");
-}
-function getDatabasePath() {
-  return join(getDefaultDataDir(), "workflows.db");
-}
-var dbInstance = null;
-function getDatabase(path) {
-  if (!dbInstance) {
-    const dbPath = path ?? getDatabasePath();
-    const dbDir = dbPath.substring(0, dbPath.lastIndexOf("/"));
-    if (dbDir && dbDir !== "/") {
-      try {
-        const { mkdirSync } = __require("fs");
-        mkdirSync(dbDir, { recursive: true });
-      } catch {}
-    }
-    dbInstance = createCompatibleDatabase(dbPath);
-    try {
-      if (typeof dbInstance.pragma === "function") {
-        dbInstance.pragma("journal_mode = WAL");
-      }
-    } catch {
-      logger?.debug("WAL mode not available, using default journal mode");
-    }
-  }
-  return dbInstance;
-}
-function closeDatabase() {
-  if (dbInstance) {
-    dbInstance.close();
-    dbInstance = null;
-  }
-}
-function initializeTables() {
-  const db = getDatabase();
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS workflows (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL UNIQUE,
-      version TEXT NOT NULL DEFAULT '1.0',
-      description TEXT,
-      definition TEXT NOT NULL,
-      config TEXT NOT NULL DEFAULT '{}',
-      metadata TEXT NOT NULL DEFAULT '{}',
-      tags TEXT NOT NULL DEFAULT '[]',
-      task_id INTEGER,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    )
-  `);
-  db.exec(`
-    CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name);
-    CREATE INDEX IF NOT EXISTS idx_workflows_tags ON workflows(tags);
-    CREATE INDEX IF NOT EXISTS idx_workflows_task_id ON workflows(task_id);
-  `);
-}
-function resetDatabase() {
-  closeDatabase();
-  dbInstance = null;
-}
-function initDatabase(path) {
-  const db = getDatabase(path);
-  initializeTables();
-  return db;
-}
-
-export { getDatabasePath, getDatabase, closeDatabase, initializeTables, resetDatabase, initDatabase };