sdkwork-browser-agent 1.0.0

package/dist/node/chunk-YDHQCPSN.cjs

@@ -0,0 +1,1569 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// src/skills/registry.ts
+var SkillRegistry = (_class = class {
+  __init() {this.skills = /* @__PURE__ */ new Map()}
+  __init2() {this.index = {
+    byName: /* @__PURE__ */ new Map(),
+    byCategory: /* @__PURE__ */ new Map(),
+    byTag: /* @__PURE__ */ new Map(),
+    byDescription: /* @__PURE__ */ new Map()
+  }}
+  
+  __init3() {this.storage = null}
+  __init4() {this.watchers = /* @__PURE__ */ new Map()}
+  constructor(config = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+    this.config = {
+      storage: _nullishCoalesce(config.storage, () => ( null)),
+      enableCache: _nullishCoalesce(config.enableCache, () => ( true)),
+      enableIndexing: _nullishCoalesce(config.enableIndexing, () => ( true)),
+      maxCacheSize: _nullishCoalesce(config.maxCacheSize, () => ( 100)),
+      cacheTTL: _nullishCoalesce(config.cacheTTL, () => ( 36e5)),
+      // 1 hour
+      hotReload: _nullishCoalesce(config.hotReload, () => ( false))
+    };
+    if (this.config.storage) {
+      this.storage = this.config.storage;
+    }
+  }
+  /**
+   * Register a skill in the registry
+   */
+  register(skill) {
+    const cached = {
+      skill,
+      loadedAt: /* @__PURE__ */ new Date(),
+      lastAccessed: /* @__PURE__ */ new Date(),
+      accessCount: 0,
+      size: this.calculateSkillSize(skill),
+      tags: _nullishCoalesce(_optionalChain([skill, 'access', _ => _.metadata, 'optionalAccess', _2 => _2.tags]), () => ( []))
+    };
+    this.skills.set(skill.name, cached);
+    if (this.config.enableIndexing) {
+      this.indexSkill(skill);
+    }
+    if (this.config.hotReload && this.storage) {
+      this.watchSkill(skill);
+    }
+  }
+  /**
+   * Unregister a skill
+   */
+  unregister(name) {
+    const skill = this.skills.get(name);
+    if (!skill) return false;
+    if (this.config.enableIndexing) {
+      this.removeFromIndex(skill.skill);
+    }
+    if (this.config.hotReload) {
+      const watcher = this.watchers.get(name);
+      if (watcher) {
+        watcher();
+        this.watchers.delete(name);
+      }
+    }
+    return this.skills.delete(name);
+  }
+  /**
+   * Get a skill by name
+   */
+  get(name) {
+    const cached = this.skills.get(name);
+    if (!cached) return void 0;
+    cached.lastAccessed = /* @__PURE__ */ new Date();
+    cached.accessCount++;
+    return cached.skill;
+  }
+  /**
+   * Check if skill exists
+   */
+  has(name) {
+    return this.skills.has(name);
+  }
+  /**
+   * Find skills by category
+   */
+  findByCategory(category) {
+    if (!this.config.enableIndexing) {
+      return this.getAll().filter((s) => _optionalChain([s, 'access', _3 => _3.metadata, 'optionalAccess', _4 => _4.category]) === category);
+    }
+    const names = this.index.byCategory.get(category);
+    if (!names) return [];
+    return Array.from(names).map((name) => this.get(name)).filter((s) => s !== void 0);
+  }
+  /**
+   * Find skills by tag
+   */
+  findByTag(tag) {
+    if (!this.config.enableIndexing) {
+      return this.getAll().filter((s) => _optionalChain([s, 'access', _5 => _5.metadata, 'optionalAccess', _6 => _6.tags, 'optionalAccess', _7 => _7.includes, 'call', _8 => _8(tag)]));
+    }
+    const names = this.index.byTag.get(tag);
+    if (!names) return [];
+    return Array.from(names).map((name) => this.get(name)).filter((s) => s !== void 0);
+  }
+  /**
+   * Search skills by keyword
+   */
+  search(keyword) {
+    const lowerKeyword = keyword.toLowerCase();
+    const results = /* @__PURE__ */ new Set();
+    for (const [name, cached] of this.skills) {
+      if (name.toLowerCase().includes(lowerKeyword)) {
+        results.add(cached.skill);
+      }
+    }
+    if (this.config.enableIndexing) {
+      const tagNames = this.index.byTag.get(lowerKeyword);
+      if (tagNames) {
+        for (const name of tagNames) {
+          const skill = this.get(name);
+          if (skill) results.add(skill);
+        }
+      }
+    } else {
+      for (const cached of this.skills.values()) {
+        if (_optionalChain([cached, 'access', _9 => _9.skill, 'access', _10 => _10.metadata, 'optionalAccess', _11 => _11.tags, 'optionalAccess', _12 => _12.some, 'call', _13 => _13((tag) => tag.toLowerCase() === lowerKeyword)])) {
+          results.add(cached.skill);
+        }
+      }
+    }
+    if (this.config.enableIndexing) {
+      for (const [desc, names] of this.index.byDescription) {
+        if (desc.includes(lowerKeyword)) {
+          for (const name of names) {
+            const skill = this.get(name);
+            if (skill) results.add(skill);
+          }
+        }
+      }
+    } else {
+      for (const cached of this.skills.values()) {
+        if (cached.skill.description.toLowerCase().includes(lowerKeyword)) {
+          results.add(cached.skill);
+        }
+      }
+    }
+    return Array.from(results);
+  }
+  /**
+   * Get all registered skills
+   */
+  getAll() {
+    return Array.from(this.skills.values()).map((c) => c.skill);
+  }
+  /**
+   * Get all skill names
+   */
+  getNames() {
+    return Array.from(this.skills.keys());
+  }
+  /**
+   * Get skills by names
+   */
+  getMany(names) {
+    return names.map((name) => this.get(name)).filter((s) => s !== void 0);
+  }
+  /**
+   * Get registry statistics
+   */
+  getStats() {
+    let totalAccessCount = 0;
+    let totalSize = 0;
+    const categories = /* @__PURE__ */ new Set();
+    const tags = /* @__PURE__ */ new Set();
+    for (const cached of this.skills.values()) {
+      totalAccessCount += cached.accessCount;
+      totalSize += cached.size;
+      if (_optionalChain([cached, 'access', _14 => _14.skill, 'access', _15 => _15.metadata, 'optionalAccess', _16 => _16.category])) {
+        categories.add(cached.skill.metadata.category);
+      }
+      cached.tags.forEach((tag) => tags.add(tag));
+    }
+    return {
+      totalSkills: this.skills.size,
+      totalSize,
+      averageAccessCount: this.skills.size > 0 ? totalAccessCount / this.skills.size : 0,
+      cacheHitRate: this.calculateCacheHitRate(),
+      categories: Array.from(categories),
+      tags: Array.from(tags)
+    };
+  }
+  /**
+   * Clear all skills
+   */
+  clear() {
+    for (const [, stop] of this.watchers) {
+      stop();
+    }
+    this.watchers.clear();
+    this.skills.clear();
+    this.clearIndex();
+  }
+  /**
+   * Clear expired cache entries
+   */
+  clearExpired() {
+    const now = Date.now();
+    let cleared = 0;
+    for (const [name, cached] of this.skills) {
+      if (now - cached.lastAccessed.getTime() > this.config.cacheTTL) {
+        this.unregister(name);
+        cleared++;
+      }
+    }
+    return cleared;
+  }
+  /**
+   * Optimize cache by removing least recently used entries
+   */
+  optimizeCache() {
+    if (this.skills.size <= this.config.maxCacheSize) return;
+    const sorted = Array.from(this.skills.entries()).sort(
+      (a, b) => a[1].lastAccessed.getTime() - b[1].lastAccessed.getTime()
+    );
+    const toRemove = sorted.slice(0, sorted.length - this.config.maxCacheSize);
+    for (const [name] of toRemove) {
+      this.unregister(name);
+    }
+  }
+  // Private methods
+  indexSkill(skill) {
+    this.index.byName.set(skill.name, skill.name);
+    if (_optionalChain([skill, 'access', _17 => _17.metadata, 'optionalAccess', _18 => _18.category])) {
+      const category = skill.metadata.category;
+      if (!this.index.byCategory.has(category)) {
+        this.index.byCategory.set(category, /* @__PURE__ */ new Set());
+      }
+      this.index.byCategory.get(category).add(skill.name);
+    }
+    _optionalChain([skill, 'access', _19 => _19.metadata, 'optionalAccess', _20 => _20.tags, 'optionalAccess', _21 => _21.forEach, 'call', _22 => _22((tag) => {
+      if (!this.index.byTag.has(tag)) {
+        this.index.byTag.set(tag, /* @__PURE__ */ new Set());
+      }
+      this.index.byTag.get(tag).add(skill.name);
+    })]);
+    const words = skill.description.toLowerCase().split(/\s+/);
+    words.forEach((word) => {
+      if (word.length > 3) {
+        if (!this.index.byDescription.has(word)) {
+          this.index.byDescription.set(word, /* @__PURE__ */ new Set());
+        }
+        this.index.byDescription.get(word).add(skill.name);
+      }
+    });
+  }
+  removeFromIndex(skill) {
+    this.index.byName.delete(skill.name);
+    if (_optionalChain([skill, 'access', _23 => _23.metadata, 'optionalAccess', _24 => _24.category])) {
+      const categorySet = this.index.byCategory.get(skill.metadata.category);
+      if (categorySet) {
+        categorySet.delete(skill.name);
+        if (categorySet.size === 0) {
+          this.index.byCategory.delete(skill.metadata.category);
+        }
+      }
+    }
+    _optionalChain([skill, 'access', _25 => _25.metadata, 'optionalAccess', _26 => _26.tags, 'optionalAccess', _27 => _27.forEach, 'call', _28 => _28((tag) => {
+      const tagSet = this.index.byTag.get(tag);
+      if (tagSet) {
+        tagSet.delete(skill.name);
+        if (tagSet.size === 0) {
+          this.index.byTag.delete(tag);
+        }
+      }
+    })]);
+    const words = skill.description.toLowerCase().split(/\s+/);
+    words.forEach((word) => {
+      const descSet = this.index.byDescription.get(word);
+      if (descSet) {
+        descSet.delete(skill.name);
+        if (descSet.size === 0) {
+          this.index.byDescription.delete(word);
+        }
+      }
+    });
+  }
+  clearIndex() {
+    this.index.byName.clear();
+    this.index.byCategory.clear();
+    this.index.byTag.clear();
+    this.index.byDescription.clear();
+  }
+  calculateSkillSize(skill) {
+    return JSON.stringify(skill).length;
+  }
+  calculateCacheHitRate() {
+    return this.skills.size > 0 ? 1 : 0;
+  }
+  watchSkill(skill) {
+    this.watchers.set(skill.name, () => {
+    });
+  }
+}, _class);
+
+// src/skills/builtin/index.ts
+var echoSkill = {
+  name: "echo",
+  description: "Echo back the input message. Use for debugging, testing, or verifying message passing in the agent system.",
+  parameters: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "The message to echo back"
+      }
+    },
+    required: ["message"]
+  },
+  handler: async (params2) => ({
+    success: true,
+    data: params2.message
+  }),
+  metadata: {
+    category: "utility",
+    tags: ["debug", "test", "utility"],
+    version: "1.0.0",
+    author: "sdkwork-browser-agent"
+  }
+};
+var mathSkill = {
+  name: "math",
+  description: "Perform mathematical calculations safely. Use when users ask for calculations, math problems, or numeric operations.",
+  parameters: {
+    type: "object",
+    properties: {
+      expression: {
+        type: "string",
+        description: "Mathematical expression to evaluate. Allowed: +, -, *, /, (), digits, decimals"
+      }
+    },
+    required: ["expression"]
+  },
+  handler: async (params) => {
+    try {
+      const expression = String(params.expression);
+      const sanitized = expression.replace(/[^0-9+\-*/().\s]/g, "");
+      if (sanitized.length === 0) {
+        return {
+          success: false,
+          error: "Invalid expression: no valid mathematical characters found"
+        };
+      }
+      if (sanitized.length > 1e3) {
+        return {
+          success: false,
+          error: "Expression too long (max 1000 characters)"
+        };
+      }
+      const result = eval(sanitized);
+      return {
+        success: true,
+        data: result,
+        metadata: {
+          originalExpression: expression,
+          sanitizedExpression: sanitized
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Invalid mathematical expression"
+      };
+    }
+  },
+  metadata: {
+    category: "utility",
+    tags: ["math", "calculation", "arithmetic", "utility"],
+    version: "1.0.0",
+    author: "sdkwork-browser-agent"
+  }
+};
+var listSkillsSkill = {
+  name: "list-skills",
+  description: "List all available skills in the registry. Use when users want to know what skills are available or need help finding a skill.",
+  parameters: {
+    type: "object",
+    properties: {
+      category: {
+        type: "string",
+        description: "Filter skills by category (optional)"
+      }
+    }
+  },
+  handler: async (params2, context) => {
+    const skills = context.agent.getAllSkills().map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      category: _optionalChain([skill, 'access', _29 => _29.metadata, 'optionalAccess', _30 => _30.category]),
+      tags: _optionalChain([skill, 'access', _31 => _31.metadata, 'optionalAccess', _32 => _32.tags])
+    }));
+    if (params2.category && typeof params2.category === "string") {
+      const filtered = skills.filter((s) => s.category === params2.category);
+      return { success: true, data: filtered };
+    }
+    return { success: true, data: skills };
+  },
+  metadata: {
+    category: "meta",
+    tags: ["introspection", "meta", "skills", "list"],
+    version: "1.0.0",
+    author: "sdkwork-browser-agent"
+  }
+};
+var lyricsGeneratorSkill = {
+  name: "lyrics-generator",
+  description: "Generate professional music lyrics for songs across all genres. Creates original, emotionally resonant lyrics with proper structure, rhyme schemes, and thematic depth.",
+  parameters: {
+    type: "object",
+    properties: {
+      theme: {
+        type: "string",
+        description: 'Main subject or emotion of the song (e.g., "love", "heartbreak", "summer romance")'
+      },
+      genre: {
+        type: "string",
+        description: 'Musical genre: "pop", "rock", "hip-hop", "country", "rnb", "edm", "folk", "jazz", "k-pop", etc.'
+      },
+      mood: {
+        type: "string",
+        description: 'Emotional tone: "happy", "sad", "romantic", "energetic", "nostalgic", etc.'
+      },
+      structure: {
+        type: "string",
+        description: 'Song structure: "verse-chorus", "verse-chorus-bridge", "aaba", etc.'
+      },
+      language: {
+        type: "string",
+        description: 'Lyrics language: "english", "chinese", "japanese", "spanish", etc.'
+      },
+      length: {
+        type: "string",
+        description: 'Song length: "short", "medium", "long"'
+      },
+      tempo: {
+        type: "string",
+        description: 'Speed: "slow", "mid-tempo", "fast"'
+      },
+      keywords: {
+        type: "array",
+        description: "Specific words or phrases to include"
+      },
+      referenceArtist: {
+        type: "string",
+        description: 'Style similar to artist (e.g., "Taylor Swift", "BTS")'
+      },
+      complexity: {
+        type: "string",
+        description: 'Lyrical sophistication: "simple", "moderate", "complex"'
+      }
+    },
+    required: ["theme"]
+  },
+  handler: async (params2, context) => {
+    try {
+      const { agent } = context;
+      const theme = String(params2.theme);
+      const genre = String(params2.genre || "pop");
+      const mood = String(params2.mood || "neutral");
+      const structure = String(params2.structure || "verse-chorus");
+      const language = String(params2.language || "english");
+      const length = String(params2.length || "medium");
+      const tempo = String(params2.tempo || "mid-tempo");
+      const keywords = Array.isArray(params2.keywords) ? params2.keywords : [];
+      const referenceArtist = params2.referenceArtist ? String(params2.referenceArtist) : "";
+      const complexity = String(params2.complexity || "moderate");
+      const lengthGuidelines = {
+        short: "2-3 minutes, minimal sections (verse-chorus-verse-chorus)",
+        medium: "3-4 minutes, standard structure with bridge",
+        long: "4-5+ minutes, extended with multiple sections"
+      };
+      const complexityGuidelines = {
+        simple: "Easy to understand, catchy, straightforward language",
+        moderate: "Balanced depth with some metaphors, accessible",
+        complex: "Rich metaphors, poetic language, sophisticated vocabulary"
+      };
+      const messages = [
+        {
+          role: "system",
+          content: `You are a professional songwriter and lyricist with expertise in all music genres. Create original, emotionally resonant lyrics with proper song structure.`
+        },
+        {
+          role: "user",
+          content: `Generate song lyrics with the following specifications:
+
+Theme: ${theme}
+Genre: ${genre}
+Mood: ${mood}
+Structure: ${structure}
+Language: ${language}
+Length: ${length} - ${lengthGuidelines[length]}
+Tempo: ${tempo}
+Complexity: ${complexity} - ${complexityGuidelines[complexity]}
+${keywords.length > 0 ? `Keywords to include: ${keywords.join(", ")}` : ""}
+${referenceArtist ? `Style reference: Similar to ${referenceArtist}` : ""}
+
+Requirements:
+1. Create original lyrics (not copying existing songs)
+2. Use proper song structure with clear section labels [Verse], [Chorus], [Bridge], etc.
+3. Include a catchy, memorable chorus
+4. Use appropriate rhyme schemes for the genre
+5. Show emotions through imagery rather than just stating them
+6. Ensure lyrics are singable and flow well
+7. Match the complexity level requested
+8. ${language !== "english" ? `Write in ${language} language` : "Write in English"}
+
+Format the output with clear section labels and line breaks for readability.`
+        }
+      ];
+      const response = await agent.chat(messages);
+      const lyrics = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      return {
+        success: true,
+        data: lyrics,
+        metadata: {
+          theme,
+          genre,
+          mood,
+          structure,
+          language,
+          length,
+          tempo,
+          keywords,
+          referenceArtist,
+          complexity
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Lyrics generation failed"
+      };
+    }
+  },
+  metadata: {
+    category: "creative",
+    tags: ["lyrics", "music", "songwriting", "composition", "creative-writing"],
+    version: "1.0.0",
+    author: "sdkwork-browser-agent"
+  }
+};
+var builtInSkills = [echoSkill, mathSkill, listSkillsSkill, lyricsGeneratorSkill];
+var builtInSkillsMap = new Map(builtInSkills.map((skill) => [skill.name, skill]));
+
+// src/skills/skill-loader.ts
+function parseSkillMd(content) {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    throw new Error("Invalid SKILL.md format: missing YAML frontmatter");
+  }
+  const yamlContent = match[1];
+  const instructions = match[2].trim();
+  const manifest = parseYaml(yamlContent);
+  if (!manifest.name || !manifest.description) {
+    throw new Error("Invalid SKILL.md: name and description are required in frontmatter");
+  }
+  if (!isValidSkillName(manifest.name)) {
+    throw new Error(
+      `Invalid skill name "${manifest.name}". Must be 1-64 chars, lowercase alphanumeric and hyphens only, cannot start/end with hyphen, no consecutive hyphens.`
+    );
+  }
+  return { manifest, instructions };
+}
+function parseYaml(yaml) {
+  const result2 = {};
+  const lines = yaml.split("\n");
+  let currentKey = null;
+  let currentIndent = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = line.match(/^(\s*)(\w+):\s*(.*)$/);
+    if (match) {
+      const [, indent, key, value] = match;
+      currentIndent = indent.length;
+      currentKey = key;
+      if (value) {
+        result2[key] = parseYamlValue(value);
+      } else {
+        result2[key] = {};
+      }
+    } else if (currentKey && line.startsWith(" ".repeat(currentIndent + 2))) {
+      const nestedMatch = line.match(/^\s+(\w+):\s*(.*)$/);
+      if (nestedMatch) {
+        const [, nestedKey, nestedValue] = nestedMatch;
+        if (typeof result2[currentKey] === "object" && result2[currentKey] !== null) {
+          result2[currentKey][nestedKey] = parseYamlValue(nestedValue);
+        }
+      }
+    }
+  }
+  return result2;
+}
+function parseYamlValue(value) {
+  const trimmed = value.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null" || trimmed === "~") return null;
+  if (/^-?\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+  if (/^-?\d+\.\d+$/.test(trimmed)) return parseFloat(trimmed);
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function isValidSkillName(name) {
+  if (name.length < 1 || name.length > 64) return false;
+  if (!/^[a-z0-9-]+$/.test(name)) return false;
+  if (name.startsWith("-") || name.endsWith("-")) return false;
+  if (name.includes("--")) return false;
+  return true;
+}
+function createSkillFromManifest(manifest, _instructions) {
+  const metadata = {
+    category: _optionalChain([manifest, 'access', _33 => _33.metadata, 'optionalAccess', _34 => _34.category]),
+    tags: _optionalChain([manifest, 'access', _35 => _35.metadata, 'optionalAccess', _36 => _36.tags, 'optionalAccess', _37 => _37.split, 'call', _38 => _38(/\s+/)]),
+    version: _optionalChain([manifest, 'access', _39 => _39.metadata, 'optionalAccess', _40 => _40.version]),
+    author: _optionalChain([manifest, 'access', _41 => _41.metadata, 'optionalAccess', _42 => _42.author])
+  };
+  const skill = {
+    name: manifest.name,
+    description: manifest.description,
+    parameters: {
+      type: "object",
+      properties: {}
+    },
+    handler: async () => ({
+      success: false,
+      error: "Skill handler not implemented. This is a manifest-only skill."
+    }),
+    metadata
+  };
+  return skill;
+}
+async function loadSkillFromDirectory(skillPath) {
+  if (typeof window !== "undefined") {
+    throw new Error("Directory loading not supported in browser environment");
+  }
+  const fs = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+  const path = await Promise.resolve().then(() => _interopRequireWildcard(require("path")));
+  const skillMdPath = path.join(skillPath, "SKILL.md");
+  try {
+    const content = await fs.readFile(skillMdPath, "utf-8");
+    const { manifest, instructions } = parseSkillMd(content);
+    const skill = createSkillFromManifest(manifest, instructions);
+    return { manifest, instructions, skill };
+  } catch (error) {
+    throw new Error(
+      `Failed to load skill from ${skillPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest.name) {
+    errors.push("Missing required field: name");
+  } else if (!isValidSkillName(manifest.name)) {
+    errors.push(`Invalid name format: "${manifest.name}"`);
+  }
+  if (!manifest.description) {
+    errors.push("Missing required field: description");
+  } else if (manifest.description.length > 1024) {
+    errors.push("Description exceeds 1024 characters");
+  }
+  if (manifest.compatibility && manifest.compatibility.length > 500) {
+    errors.push("Compatibility exceeds 500 characters");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/skills/skill-resource-manager.ts
+var SkillResourceManager = (_class2 = class {
+  
+  __init5() {this.cache = /* @__PURE__ */ new Map()}
+  __init6() {this.metadataCache = /* @__PURE__ */ new Map()}
+  constructor(config = {}) {;_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);
+    this.config = {
+      basePath: _nullishCoalesce(config.basePath, () => ( "./skills")),
+      enableCaching: _nullishCoalesce(config.enableCaching, () => ( true)),
+      maxCacheSize: _nullishCoalesce(config.maxCacheSize, () => ( 50))
+    };
+  }
+  /**
+   * Level 1: Load metadata only (~100 tokens)
+   * Loaded at startup for all skills
+   */
+  async loadMetadata(skillPath) {
+    if (this.config.enableCaching && this.metadataCache.has(skillPath)) {
+      return this.metadataCache.get(skillPath);
+    }
+    const content = await this.readFile(`${skillPath}/SKILL.md`);
+    if (!content) {
+      throw new Error(`SKILL.md not found at ${skillPath}`);
+    }
+    const { manifest } = this.parseSkillMd(content);
+    this.validateManifest(manifest, skillPath);
+    if (this.config.enableCaching) {
+      this.metadataCache.set(skillPath, manifest);
+    }
+    return manifest;
+  }
+  /**
+   * Level 2: Load instructions (< 5000 tokens)
+   * Loaded when skill is activated
+   */
+  async loadInstructions(skillPath) {
+    const content = await this.readFile(`${skillPath}/SKILL.md`);
+    if (!content) {
+      throw new Error(`SKILL.md not found at ${skillPath}`);
+    }
+    const { instructions } = this.parseSkillMd(content);
+    return instructions;
+  }
+  /**
+   * Level 3: Load complete skill with resources
+   * Resources loaded as needed
+   */
+  async loadFullSkill(skillPath) {
+    if (this.config.enableCaching && this.cache.has(skillPath)) {
+      return this.cache.get(skillPath);
+    }
+    const manifest = await this.loadMetadata(skillPath);
+    const instructions = await this.loadInstructions(skillPath);
+    const scripts = await this.loadScripts(skillPath);
+    const references = await this.loadReferences(skillPath);
+    const assets = await this.loadAssets(skillPath);
+    const skill = {
+      name: manifest.name,
+      path: skillPath,
+      manifest,
+      instructions,
+      scripts,
+      references,
+      assets,
+      currentLevel: "resources",
+      loadedAt: /* @__PURE__ */ new Date()
+    };
+    if (this.config.enableCaching) {
+      this.cache.set(skillPath, skill);
+      this.enforceCacheLimit();
+    }
+    return skill;
+  }
+  /**
+   * Progressive loading - load up to specified level
+   */
+  async loadProgressive(skillPath, level = "metadata") {
+    const manifest = await this.loadMetadata(skillPath);
+    const skill = {
+      name: manifest.name,
+      path: skillPath,
+      manifest,
+      scripts: /* @__PURE__ */ new Map(),
+      references: /* @__PURE__ */ new Map(),
+      assets: /* @__PURE__ */ new Map(),
+      currentLevel: "metadata",
+      loadedAt: /* @__PURE__ */ new Date()
+    };
+    if (level === "metadata") {
+      return skill;
+    }
+    skill.instructions = await this.loadInstructions(skillPath);
+    skill.currentLevel = "instructions";
+    if (level === "instructions") {
+      return skill;
+    }
+    skill.scripts = await this.loadScripts(skillPath);
+    skill.references = await this.loadReferences(skillPath);
+    skill.assets = await this.loadAssets(skillPath);
+    skill.currentLevel = "resources";
+    return skill;
+  }
+  /**
+   * Load a specific resource on demand
+   */
+  async loadResource(skillPath, type, name) {
+    switch (type) {
+      case "script":
+        return this.loadScript(skillPath, name);
+      case "reference":
+        return this.loadReference(skillPath, name);
+      case "asset":
+        return this.loadAsset(skillPath, name);
+      default:
+        return null;
+    }
+  }
+  /**
+   * Get reference content
+   */
+  async getReference(skillPath, referenceName) {
+    const reference = await this.loadReference(skillPath, referenceName);
+    return _nullishCoalesce(_optionalChain([reference, 'optionalAccess', _43 => _43.content]), () => ( null));
+  }
+  /**
+   * Get asset content
+   */
+  async getAsset(skillPath, assetName) {
+    const asset = await this.loadAsset(skillPath, assetName);
+    return _nullishCoalesce(_optionalChain([asset, 'optionalAccess', _44 => _44.content]), () => ( null));
+  }
+  // Private methods
+  async loadScripts(skillPath) {
+    const scripts = /* @__PURE__ */ new Map();
+    try {
+      const files = await this.listDirectory(`${skillPath}/scripts`);
+      for (const file of files) {
+        const content = await this.readFile(`${skillPath}/scripts/${file}`);
+        if (content) {
+          const language = this.detectLanguage(file);
+          scripts.set(file, {
+            name: file,
+            path: `${skillPath}/scripts/${file}`,
+            language,
+            content
+          });
+        }
+      }
+    } catch (e2) {
+    }
+    return scripts;
+  }
+  async loadReferences(skillPath) {
+    const references = /* @__PURE__ */ new Map();
+    try {
+      const files = await this.listDirectory(`${skillPath}/references`);
+      for (const file of files) {
+        if (file.endsWith(".md")) {
+          const content = await this.readFile(`${skillPath}/references/${file}`);
+          if (content) {
+            references.set(file, {
+              name: file,
+              path: `${skillPath}/references/${file}`,
+              content
+            });
+          }
+        }
+      }
+    } catch (e3) {
+    }
+    return references;
+  }
+  async loadAssets(skillPath) {
+    const assets = /* @__PURE__ */ new Map();
+    try {
+      const files = await this.listDirectory(`${skillPath}/assets`);
+      for (const file of files) {
+        const content = await this.readFile(`${skillPath}/assets/${file}`);
+        if (content) {
+          assets.set(file, {
+            name: file,
+            path: `${skillPath}/assets/${file}`,
+            type: this.detectAssetType(file),
+            content
+          });
+        }
+      }
+    } catch (e4) {
+    }
+    return assets;
+  }
+  async loadScript(skillPath, name) {
+    const content = await this.readFile(`${skillPath}/scripts/${name}`);
+    if (!content) return null;
+    return {
+      name,
+      path: `${skillPath}/scripts/${name}`,
+      language: this.detectLanguage(name),
+      content
+    };
+  }
+  async loadReference(skillPath, name) {
+    const content = await this.readFile(`${skillPath}/references/${name}`);
+    if (!content) return null;
+    return {
+      name,
+      path: `${skillPath}/references/${name}`,
+      content
+    };
+  }
+  async loadAsset(skillPath, name) {
+    const content = await this.readFile(`${skillPath}/assets/${name}`);
+    if (!content) return null;
+    return {
+      name,
+      path: `${skillPath}/assets/${name}`,
+      type: this.detectAssetType(name),
+      content
+    };
+  }
+  parseSkillMd(content) {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+      throw new Error("Invalid SKILL.md format: missing YAML frontmatter");
+    }
+    const yamlContent = match[1];
+    const instructions = match[2].trim();
+    return { manifest: this.parseYaml(yamlContent), instructions };
+  }
+  parseYaml(yaml) {
+    const result2 = {};
+    const lines = yaml.split("\n");
+    let currentKey = null;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const match = line.match(/^(\w+):\s*(.*)$/);
+      if (match) {
+        const [, key, value] = match;
+        currentKey = key;
+        result2[key] = value ? this.parseYamlValue(value) : {};
+      } else if (currentKey && line.startsWith("  ")) {
+        const nestedMatch = line.match(/^\s+(\w+):\s*(.*)$/);
+        if (nestedMatch && typeof result2[currentKey] === "object") {
+          const [, nestedKey, nestedValue] = nestedMatch;
+          result2[currentKey][nestedKey] = this.parseYamlValue(nestedValue);
+        }
+      }
+    }
+    return result2;
+  }
+  parseYamlValue(value) {
+    const trimmed = value.trim();
+    if (trimmed === "true") return true;
+    if (trimmed === "false") return false;
+    if (trimmed === "null") return null;
+    if (/^-?\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+    if (/^-?\d+\.\d+$/.test(trimmed)) return parseFloat(trimmed);
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed.slice(1, -1);
+    }
+    return trimmed;
+  }
+  /**
+   * Validate manifest according to Agent Skills Specification
+   */
+  validateManifest(manifest, skillPath) {
+    if (!manifest.name) {
+      throw new Error("Skill manifest missing required field: name");
+    }
+    if (!manifest.description) {
+      throw new Error("Skill manifest missing required field: description");
+    }
+    const expectedName = skillPath.split("/").pop();
+    if (manifest.name !== expectedName) {
+      throw new Error(`Skill name "${manifest.name}" must match directory name "${expectedName}"`);
+    }
+    if (!/^[a-z0-9-]+$/.test(manifest.name)) {
+      throw new Error(
+        `Skill name "${manifest.name}" contains invalid characters. Only lowercase alphanumeric and hyphens allowed.`
+      );
+    }
+    if (manifest.name.startsWith("-") || manifest.name.endsWith("-")) {
+      throw new Error("Skill name cannot start or end with hyphen");
+    }
+    if (manifest.name.includes("--")) {
+      throw new Error("Skill name cannot contain consecutive hyphens");
+    }
+    if (manifest.name.length < 1 || manifest.name.length > 64) {
+      throw new Error("Skill name must be 1-64 characters");
+    }
+    if (manifest.description.length < 1 || manifest.description.length > 1024) {
+      throw new Error("Skill description must be 1-1024 characters");
+    }
+    if (manifest.compatibility && manifest.compatibility.length > 500) {
+      throw new Error("Compatibility field exceeds 500 characters");
+    }
+  }
+  detectLanguage(filename) {
+    const ext = _optionalChain([filename, 'access', _45 => _45.split, 'call', _46 => _46("."), 'access', _47 => _47.pop, 'call', _48 => _48(), 'optionalAccess', _49 => _49.toLowerCase, 'call', _50 => _50()]);
+    switch (ext) {
+      case "js":
+        return "javascript";
+      case "ts":
+        return "typescript";
+      case "py":
+        return "python";
+      case "sh":
+        return "bash";
+      default:
+        return "javascript";
+    }
+  }
+  detectAssetType(filename) {
+    const ext = _optionalChain([filename, 'access', _51 => _51.split, 'call', _52 => _52("."), 'access', _53 => _53.pop, 'call', _54 => _54(), 'optionalAccess', _55 => _55.toLowerCase, 'call', _56 => _56()]);
+    if (["json", "yaml", "yml", "csv", "xml"].includes(ext || "")) return "data";
+    if (["png", "jpg", "jpeg", "gif", "svg"].includes(ext || "")) return "image";
+    if (["template", "tpl"].includes(ext || "")) return "template";
+    return "other";
+  }
+  enforceCacheLimit() {
+    if (this.cache.size > this.config.maxCacheSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+  }
+  // File system abstraction
+  async readFile(path) {
+    if (typeof window !== "undefined") {
+      try {
+        const response = await fetch(path);
+        if (!response.ok) return null;
+        return await response.text();
+      } catch (e5) {
+        return null;
+      }
+    } else {
+      try {
+        const fs = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+        return await fs.readFile(path, "utf-8");
+      } catch (e6) {
+        return null;
+      }
+    }
+  }
+  async listDirectory(path) {
+    if (typeof window !== "undefined") {
+      return [];
+    } else {
+      try {
+        const fs = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+        const entries = await fs.readdir(path, { withFileTypes: true });
+        return entries.filter((e) => e.isFile()).map((e) => e.name);
+      } catch (e7) {
+        return [];
+      }
+    }
+  }
+}, _class2);
+
+// src/skills/skill-script-executor.ts
+var SkillScriptExecutor = (_class3 = class {
+  
+  __init7() {this.executionCount = 0}
+  constructor(config = {}) {;_class3.prototype.__init7.call(this);
+    this.config = {
+      timeout: _nullishCoalesce(config.timeout, () => ( 3e4)),
+      allowedGlobals: _nullishCoalesce(config.allowedGlobals, () => ( [
+        "console",
+        "Math",
+        "JSON",
+        "Date",
+        "Array",
+        "Object",
+        "String",
+        "Number",
+        "Boolean",
+        "Promise",
+        "Set",
+        "Map",
+        "Error",
+        "RegExp",
+        "ArrayBuffer",
+        "Uint8Array",
+        "TextEncoder",
+        "TextDecoder"
+      ])),
+      restrictedGlobals: _nullishCoalesce(config.restrictedGlobals, () => ( [
+        "eval",
+        "Function",
+        "require",
+        "import",
+        "exports",
+        "module",
+        "process",
+        "global",
+        "globalThis",
+        "window",
+        "document",
+        "fetch",
+        "XMLHttpRequest",
+        "WebSocket",
+        "localStorage",
+        "sessionStorage",
+        "indexedDB"
+      ])),
+      maxMemoryMB: _nullishCoalesce(config.maxMemoryMB, () => ( 100)),
+      allowedTools: _nullishCoalesce(config.allowedTools, () => ( [])),
+      enableLogging: _nullishCoalesce(config.enableLogging, () => ( false))
+    };
+  }
+  /**
+   * Execute a script with given operation and parameters
+   */
+  async execute(script, operation, params2, context) {
+    const startTime = Date.now();
+    const executionId = ++this.executionCount;
+    if (this.config.enableLogging) {
+      console.log(`[ScriptExecutor:${executionId}] Starting execution of ${script.name}`);
+    }
+    try {
+      if (!this.isScriptAllowed(script)) {
+        return {
+          success: false,
+          error: `Script execution not allowed. Check allowed-tools in SKILL.md`,
+          executionTime: Date.now() - startTime
+        };
+      }
+      let result2;
+      switch (script.language) {
+        case "javascript":
+        case "typescript":
+          result2 = await this.executeJavaScript(script.content, operation, params2, context);
+          break;
+        case "python":
+          result2 = await this.executePython(script.content, operation, params2);
+          break;
+        case "bash":
+          result2 = await this.executeBash(script.content, operation, params2);
+          break;
+        default:
+          return {
+            success: false,
+            error: `Unsupported language: ${script.language}`,
+            executionTime: Date.now() - startTime
+          };
+      }
+      if (this.config.enableLogging) {
+        console.log(`[ScriptExecutor:${executionId}] Execution completed successfully`);
+      }
+      return {
+        success: true,
+        output: result2,
+        executionTime: Date.now() - startTime
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (this.config.enableLogging) {
+        console.error(`[ScriptExecutor:${executionId}] Execution failed:`, errorMessage);
+      }
+      return {
+        success: false,
+        error: errorMessage,
+        executionTime: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * Check if script is allowed to execute based on allowed-tools configuration
+   */
+  isScriptAllowed(script) {
+    if (this.config.allowedTools.length === 0) {
+      return true;
+    }
+    return this.config.allowedTools.some((pattern) => {
+      if (pattern.includes("*")) {
+        const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+        return regex.test(script.name);
+      }
+      return pattern === script.name;
+    });
+  }
+  /**
+   * Execute JavaScript/TypeScript in secure sandbox
+   */
+  async executeJavaScript(code, operation, params2, _context) {
+    const sanitizedCode = this.sanitizeJavaScript(code);
+    const sandbox = this.createSandbox(operation, params2);
+    const wrappedCode = `
+      "use strict";
+      ${sanitizedCode}
+      if (typeof handler === 'function') {
+        return await handler(operation, params);
+      }
+      if (typeof main === 'function') {
+        return await main(operation, params);
+      }
+      throw new Error('Script must export a handler or main function');
+    `;
+    if (typeof window !== "undefined") {
+      return this.executeInBrowserWorker(wrappedCode, sandbox);
+    } else {
+      return this.executeInNodeVM(wrappedCode, sandbox);
+    }
+  }
+  /**
+   * Sanitize JavaScript code to remove dangerous patterns
+   */
+  sanitizeJavaScript(code) {
+    let sanitized2 = code.replace(/eval\s*\(/gi, "/* eval blocked */(").replace(/new\s+Function\s*\(/gi, "/* Function blocked */(").replace(/import\s*\(/gi, "/* dynamic import blocked */(");
+    for (const restricted of this.config.restrictedGlobals) {
+      const pattern = new RegExp(`\\b${restricted}\\b`, "g");
+      sanitized2 = sanitized2.replace(pattern, `/* ${restricted} blocked */`);
+    }
+    return sanitized2;
+  }
+  /**
+   * Create sandbox context with allowed globals
+   */
+  createSandbox(operation, params2) {
+    const logs = [];
+    return {
+      params: params2,
+      operation,
+      console: {
+        log: (...args) => {
+          logs.push(args);
+          if (this.config.enableLogging) {
+            console.log("[Skill]", ...args);
+          }
+        },
+        error: (...args) => {
+          logs.push(args);
+          if (this.config.enableLogging) {
+            console.error("[Skill]", ...args);
+          }
+        },
+        warn: (...args) => {
+          logs.push(args);
+          if (this.config.enableLogging) {
+            console.warn("[Skill]", ...args);
+          }
+        },
+        info: (...args) => {
+          logs.push(args);
+          if (this.config.enableLogging) {
+            console.info("[Skill]", ...args);
+          }
+        }
+      },
+      Math,
+      JSON,
+      Date,
+      Array,
+      Object,
+      String,
+      Number,
+      Boolean,
+      Promise,
+      Set,
+      Map,
+      Error,
+      RegExp,
+      ArrayBuffer,
+      Uint8Array,
+      TextEncoder,
+      TextDecoder
+    };
+  }
+  /**
+   * Execute JavaScript in browser using Web Worker
+   */
+  executeInBrowserWorker(code, sandbox) {
+    return new Promise((resolve, reject) => {
+      const workerScript = `
+        self.onmessage = async function(e) {
+          try {
+            const { code, sandbox } = e.data;
+            
+            // Create function with sandbox bindings
+            const fn = new Function('sandbox', \`
+              with (sandbox) {
+                return (async () => {
+                  \${code}
+                })();
+              }
+            \`);
+            
+            const result = await fn(sandbox);
+            self.postMessage({ success: true, result });
+          } catch (error) {
+            self.postMessage({ success: false, error: error.message });
+          }
+        };
+      `;
+      const blob = new Blob([workerScript], { type: "application/javascript" });
+      const workerUrl = URL.createObjectURL(blob);
+      const worker = new Worker(workerUrl);
+      const timeoutId = setTimeout(() => {
+        worker.terminate();
+        URL.revokeObjectURL(workerUrl);
+        reject(new Error(`Script execution timeout after ${this.config.timeout}ms`));
+      }, this.config.timeout);
+      worker.onmessage = (e) => {
+        clearTimeout(timeoutId);
+        worker.terminate();
+        URL.revokeObjectURL(workerUrl);
+        if (e.data.success) {
+          resolve(e.data.result);
+        } else {
+          reject(new Error(e.data.error));
+        }
+      };
+      worker.onerror = (error) => {
+        clearTimeout(timeoutId);
+        worker.terminate();
+        URL.revokeObjectURL(workerUrl);
+        reject(error);
+      };
+      worker.postMessage({ code, sandbox });
+    });
+  }
+  /**
+   * Execute JavaScript in Node.js using VM module
+   */
+  async executeInNodeVM(code, sandbox) {
+    const vm = await Promise.resolve().then(() => _interopRequireWildcard(require("vm")));
+    const context = vm.createContext(sandbox);
+    const script = new vm.Script(code);
+    return script.runInContext(context);
+  }
+  /**
+   * Execute Python code (requires Python runtime)
+   */
+  async executePython(code, operation, params2) {
+    if (typeof window !== "undefined") {
+      throw new Error("Python execution not supported in browser environment");
+    }
+    const { spawn } = await Promise.resolve().then(() => _interopRequireWildcard(require("child_process")));
+    const inputData = JSON.stringify({ operation, params: params2 });
+    return new Promise((resolve, reject) => {
+      const pythonProcess = spawn("python3", ["-c", code]);
+      let output = "";
+      let errorOutput = "";
+      pythonProcess.stdout.on("data", (data) => {
+        output += data.toString();
+      });
+      pythonProcess.stderr.on("data", (data) => {
+        errorOutput += data.toString();
+      });
+      pythonProcess.on("close", (code2) => {
+        if (code2 === 0) {
+          try {
+            resolve(JSON.parse(output));
+          } catch (e8) {
+            resolve(output.trim());
+          }
+        } else {
+          reject(new Error(errorOutput || `Python process exited with code ${code2}`));
+        }
+      });
+      _optionalChain([pythonProcess, 'access', _57 => _57.stdin, 'optionalAccess', _58 => _58.write, 'call', _59 => _59(inputData)]);
+      _optionalChain([pythonProcess, 'access', _60 => _60.stdin, 'optionalAccess', _61 => _61.end, 'call', _62 => _62()]);
+      setTimeout(() => {
+        pythonProcess.kill();
+        reject(new Error("Python execution timeout"));
+      }, this.config.timeout);
+    });
+  }
+  /**
+   * Execute Bash script (Node.js only)
+   */
+  async executeBash(code, _operation, _params) {
+    if (typeof window !== "undefined") {
+      throw new Error("Bash execution not supported in browser environment");
+    }
+    const { exec } = await Promise.resolve().then(() => _interopRequireWildcard(require("child_process")));
+    const { promisify } = await Promise.resolve().then(() => _interopRequireWildcard(require("util")));
+    const execAsync = promisify(exec);
+    const { stdout, stderr } = await execAsync(code, {
+      timeout: this.config.timeout,
+      maxBuffer: this.config.maxMemoryMB * 1024 * 1024
+    });
+    if (stderr) {
+      throw new Error(stderr);
+    }
+    return stdout.trim();
+  }
+  /**
+   * Get executor statistics
+   */
+  getStats() {
+    return {
+      totalExecutions: this.executionCount,
+      config: { ...this.config }
+    };
+  }
+}, _class3);
+
+// src/skills/enhanced-skill-executor.ts
+var EnhancedSkillExecutor = class {
+  
+  
+  
+  constructor(config = {}) {
+    this.resourceManager = _nullishCoalesce(config.resourceManager, () => ( new SkillResourceManager()));
+    this.scriptExecutor = _nullishCoalesce(config.scriptExecutor, () => ( new SkillScriptExecutor()));
+    this.defaultScriptName = _nullishCoalesce(config.defaultScriptName, () => ( "handler.js"));
+  }
+  /**
+   * Execute a skill with full resource loading
+   *
+   * This method:
+   * 1. Loads the skill with all resources (if not cached)
+   * 2. Finds the appropriate script
+   * 3. Executes the script with the operation and parameters
+   * 4. Returns the result
+   */
+  async execute(skillPath, operation, params2 = {}, context) {
+    try {
+      const skill = await this.resourceManager.loadFullSkill(skillPath);
+      const scriptName = this.findScript(skill, operation);
+      if (!scriptName) {
+        return {
+          success: false,
+          error: `No script found for operation "${operation}" in skill "${skill.name}"`
+        };
+      }
+      const script = skill.scripts.get(scriptName);
+      if (!script) {
+        return {
+          success: false,
+          error: `Script "${scriptName}" not found in skill "${skill.name}"`
+        };
+      }
+      const result2 = await this.scriptExecutor.execute(
+        script,
+        operation,
+        params2,
+        context
+      );
+      if (result2.success) {
+        return {
+          success: true,
+          data: result2.output,
+          metadata: {
+            skillName: skill.name,
+            operation,
+            scriptName,
+            executionTime: result2.executionTime
+          }
+        };
+      } else {
+        return {
+          success: false,
+          error: result2.error || "Script execution failed",
+          metadata: {
+            skillName: skill.name,
+            operation,
+            scriptName,
+            executionTime: result2.executionTime
+          }
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Execute skill with progressive loading
+   * Loads only metadata first, then instructions if needed, then resources
+   */
+  async executeProgressive(skillPath, operation, params2 = {}, context) {
+    try {
+      const metadata = await this.resourceManager.loadMetadata(skillPath);
+      const instructions = await this.resourceManager.loadInstructions(skillPath);
+      if (!this.operationSupported(instructions, operation)) {
+        return {
+          success: false,
+          error: `Operation "${operation}" not supported by skill "${metadata.name}"`
+        };
+      }
+      return this.execute(skillPath, operation, params2, context);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get skill information without loading resources
+   */
+  async getSkillInfo(skillPath) {
+    const skill = await this.resourceManager.loadProgressive(skillPath, "instructions");
+    return {
+      name: skill.manifest.name,
+      description: skill.manifest.description,
+      hasScripts: skill.scripts.size > 0,
+      hasReferences: skill.references.size > 0,
+      hasAssets: skill.assets.size > 0
+    };
+  }
+  /**
+   * Get reference documentation
+   */
+  async getReference(skillPath, referenceName) {
+    return this.resourceManager.getReference(skillPath, referenceName);
+  }
+  /**
+   * Get asset content
+   */
+  async getAsset(skillPath, assetName) {
+    return this.resourceManager.getAsset(skillPath, assetName);
+  }
+  /**
+   * List all available skills in a directory
+   */
+  async listSkills(directoryPath) {
+    const skills = [];
+    try {
+      if (typeof window === "undefined") {
+        const fs = await Promise.resolve().then(() => _interopRequireWildcard(require("fs/promises")));
+        const path = await Promise.resolve().then(() => _interopRequireWildcard(require("path")));
+        const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const skillPath = path.join(directoryPath, entry.name);
+            try {
+              const manifest = await this.resourceManager.loadMetadata(skillPath);
+              skills.push({
+                path: skillPath,
+                name: manifest.name,
+                description: manifest.description
+              });
+            } catch (e9) {
+            }
+          }
+        }
+      }
+    } catch (e10) {
+    }
+    return skills;
+  }
+  // Private helper methods
+  findScript(skill, operation) {
+    const operationScript = `${operation}.js`;
+    if (skill.scripts.has(operationScript)) {
+      return operationScript;
+    }
+    if (skill.scripts.has(this.defaultScriptName)) {
+      return this.defaultScriptName;
+    }
+    if (skill.scripts.has("index.js")) {
+      return "index.js";
+    }
+    const firstScript = skill.scripts.keys().next().value;
+    return _nullishCoalesce(firstScript, () => ( null));
+  }
+  operationSupported(instructions, operation) {
+    const lowerInstructions = instructions.toLowerCase();
+    const lowerOperation = operation.toLowerCase();
+    return lowerInstructions.includes(lowerOperation) || lowerInstructions.includes("## " + lowerOperation) || lowerInstructions.includes("### " + lowerOperation);
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.SkillRegistry = SkillRegistry; exports.echoSkill = echoSkill; exports.mathSkill = mathSkill; exports.listSkillsSkill = listSkillsSkill; exports.builtInSkills = builtInSkills; exports.builtInSkillsMap = builtInSkillsMap; exports.parseSkillMd = parseSkillMd; exports.createSkillFromManifest = createSkillFromManifest; exports.loadSkillFromDirectory = loadSkillFromDirectory; exports.validateManifest = validateManifest; exports.SkillResourceManager = SkillResourceManager; exports.SkillScriptExecutor = SkillScriptExecutor; exports.EnhancedSkillExecutor = EnhancedSkillExecutor;
+//# sourceMappingURL=chunk-YDHQCPSN.cjs.map