@zenobius/opencode-skillful 1.2.1 → 1.2.2-next.2

package/dist/index.js

@@ -17763,9 +17763,10 @@ function createSkillFinder(provider) {
 }
 
 // src/tools/SkillResourceReader.ts
-import path from "path";
+import path2 from "path";
 
 // src/services/SkillResourceResolver.ts
+import path from "path";
 function createSkillResourceResolver(provider) {
   const resolveResourceMap = (skill, type) => {
     if (type === "script" || type === "scripts") {
@@ -17787,7 +17788,7 @@ function createSkillResourceResolver(provider) {
     if (!resourceMap) {
       throw new Error(`Skill "${args.skill_name}" does not have any resources of type "${args.type}"`);
     }
-    const resourceEntry = resourceMap.get(args.relative_path);
+    const resourceEntry = resourceMap.get(path.join(args.type, args.relative_path));
     if (!resourceEntry) {
       throw new Error(`Resource not found: Skill "${args.skill_name}" does not have a ${args.type} at path "${args.relative_path}"`);
     }
@@ -17813,7 +17814,7 @@ function createSkillResourceReader(provider) {
     const resource = await skillResourceResolver({
       skill_name: args.skill_name,
       type,
-      relative_path: path.join(...restPath)
+      relative_path: path2.join(...restPath)
     });
     const injection = {
       skill_name: args.skill_name,
@@ -18326,10 +18327,10 @@ async function loadConfig({
 var defaultConfigDir = resolve(process.cwd(), "config");
 var defaultGeneratedDir = resolve(process.cwd(), "src/generated");
 function getProjectRoot(filePath, options2 = {}) {
-  let path2 = process2.cwd();
-  while (path2.includes("storage"))
-    path2 = resolve2(path2, "..");
-  const finalPath = resolve2(path2, filePath || "");
+  let path3 = process2.cwd();
+  while (path3.includes("storage"))
+    path3 = resolve2(path3, "..");
+  const finalPath = resolve2(path3, filePath || "");
   if (options2?.relative)
     return relative3(process2.cwd(), finalPath);
   return finalPath;
@@ -19776,10 +19777,10 @@ function applyEnvVarsToConfig(name, config3, verbose = false) {
     return config3;
   const envPrefix = name.toUpperCase().replace(/-/g, "_");
   const result = { ...config3 };
-  function processObject(obj, path2 = []) {
+  function processObject(obj, path3 = []) {
     const result2 = { ...obj };
     for (const [key, value] of Object.entries(obj)) {
-      const envPath = [...path2, key];
+      const envPath = [...path3, key];
       const formatKey = (k) => k.replace(/([A-Z])/g, "_$1").toUpperCase();
       const envKey = `${envPrefix}_${envPath.map(formatKey).join("_")}`;
       const oldEnvKey = `${envPrefix}_${envPath.map((p) => p.toUpperCase()).join("_")}`;
@@ -19961,10 +19962,10 @@ async function loadConfig3({
 var defaultConfigDir2 = resolve3(process6.cwd(), "config");
 var defaultGeneratedDir2 = resolve3(process6.cwd(), "src/generated");
 function getProjectRoot2(filePath, options2 = {}) {
-  let path2 = process7.cwd();
-  while (path2.includes("storage"))
-    path2 = resolve4(path2, "..");
-  const finalPath = resolve4(path2, filePath || "");
+  let path3 = process7.cwd();
+  while (path3.includes("storage"))
+    path3 = resolve4(path3, "..");
+  const finalPath = resolve4(path3, filePath || "");
   if (options2?.relative)
     return relative2(process7.cwd(), finalPath);
   return finalPath;
@@ -21401,10 +21402,10 @@ class EnvVarError extends BunfigError {
 
 class FileSystemError extends BunfigError {
   code = "FILE_SYSTEM_ERROR";
-  constructor(operation, path2, cause) {
-    super(`File system ${operation} failed for "${path2}": ${cause.message}`, {
+  constructor(operation, path3, cause) {
+    super(`File system ${operation} failed for "${path3}": ${cause.message}`, {
       operation,
-      path: path2,
+      path: path3,
       originalError: cause.name,
       originalMessage: cause.message
     });
@@ -21477,8 +21478,8 @@ var ErrorFactory = {
   envVar(envKey, envValue, expectedType, configName) {
     return new EnvVarError(envKey, envValue, expectedType, configName);
   },
-  fileSystem(operation, path2, cause) {
-    return new FileSystemError(operation, path2, cause);
+  fileSystem(operation, path3, cause) {
+    return new FileSystemError(operation, path3, cause);
   },
   typeGeneration(configDir, outputPath, cause) {
     return new TypeGenerationError(configDir, outputPath, cause);
@@ -21614,9 +21615,9 @@ class EnvProcessor {
     }
     return key.replace(/([A-Z])/g, "_$1").toUpperCase();
   }
-  processObject(obj, path2, envPrefix, options2) {
+  processObject(obj, path3, envPrefix, options2) {
     for (const [key, value] of Object.entries(obj)) {
-      const envPath = [...path2, key];
+      const envPath = [...path3, key];
       const formattedKeys = envPath.map((k) => this.formatEnvKey(k, options2.useCamelCase));
       const envKey = `${envPrefix}_${formattedKeys.join("_")}`;
       const oldEnvKey = options2.useBackwardCompatibility ? `${envPrefix}_${envPath.map((p) => p.toUpperCase()).join("_")}` : null;
@@ -21701,9 +21702,9 @@ class EnvProcessor {
         return this.formatAsText(envVars, configName);
     }
   }
-  extractEnvVarInfo(obj, path2, prefix, envVars) {
+  extractEnvVarInfo(obj, path3, prefix, envVars) {
     for (const [key, value] of Object.entries(obj)) {
-      const envPath = [...path2, key];
+      const envPath = [...path3, key];
       const envKey = `${prefix}_${envPath.map((k) => this.formatEnvKey(k, true)).join("_")}`;
       if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         this.extractEnvVarInfo(value, envPath, prefix, envVars);
@@ -22118,15 +22119,15 @@ class ConfigFileLoader {
   }
   async preloadConfigurations(configPaths, options2 = {}) {
     const preloaded = new Map;
-    await Promise.allSettled(configPaths.map(async (path2) => {
+    await Promise.allSettled(configPaths.map(async (path3) => {
       try {
-        const result = await this.loadFromPath(path2, {}, options2);
+        const result = await this.loadFromPath(path3, {}, options2);
         if (result) {
-          preloaded.set(path2, result.config);
+          preloaded.set(path3, result.config);
         }
       } catch (error45) {
         if (options2.verbose) {
-          console.warn(`Failed to preload ${path2}:`, error45);
+          console.warn(`Failed to preload ${path3}:`, error45);
         }
       }
     }));
@@ -22205,13 +22206,13 @@ class ConfigValidator {
       warnings
     };
   }
-  validateObjectAgainstSchema(value, schema, path2, errors3, warnings, options2) {
+  validateObjectAgainstSchema(value, schema, path3, errors3, warnings, options2) {
     if (options2.validateTypes && schema.type) {
       const actualType = Array.isArray(value) ? "array" : typeof value;
       const expectedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
       if (!expectedTypes.includes(actualType)) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: `Expected type ${expectedTypes.join(" or ")}, got ${actualType}`,
           expected: expectedTypes.join(" or "),
           actual: actualType,
@@ -22223,7 +22224,7 @@ class ConfigValidator {
     }
     if (schema.enum && !schema.enum.includes(value)) {
       errors3.push({
-        path: path2,
+        path: path3,
         message: `Value must be one of: ${schema.enum.join(", ")}`,
         expected: schema.enum.join(", "),
         actual: value,
@@ -22235,7 +22236,7 @@ class ConfigValidator {
     if (typeof value === "string") {
       if (schema.minLength !== undefined && value.length < schema.minLength) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: `String length must be at least ${schema.minLength}`,
           expected: `>= ${schema.minLength}`,
           actual: value.length,
@@ -22244,7 +22245,7 @@ class ConfigValidator {
       }
       if (schema.maxLength !== undefined && value.length > schema.maxLength) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: `String length must not exceed ${schema.maxLength}`,
           expected: `<= ${schema.maxLength}`,
           actual: value.length,
@@ -22255,7 +22256,7 @@ class ConfigValidator {
         const regex = new RegExp(schema.pattern);
         if (!regex.test(value)) {
           errors3.push({
-            path: path2,
+            path: path3,
             message: `String does not match pattern ${schema.pattern}`,
             expected: schema.pattern,
             actual: value,
@@ -22267,7 +22268,7 @@ class ConfigValidator {
     if (typeof value === "number") {
       if (schema.minimum !== undefined && value < schema.minimum) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: `Value must be at least ${schema.minimum}`,
           expected: `>= ${schema.minimum}`,
           actual: value,
@@ -22276,7 +22277,7 @@ class ConfigValidator {
       }
       if (schema.maximum !== undefined && value > schema.maximum) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: `Value must not exceed ${schema.maximum}`,
           expected: `<= ${schema.maximum}`,
           actual: value,
@@ -22286,7 +22287,7 @@ class ConfigValidator {
     }
     if (Array.isArray(value) && schema.items) {
       for (let i = 0;i < value.length; i++) {
-        const itemPath = path2 ? `${path2}[${i}]` : `[${i}]`;
+        const itemPath = path3 ? `${path3}[${i}]` : `[${i}]`;
         this.validateObjectAgainstSchema(value[i], schema.items, itemPath, errors3, warnings, options2);
         if (options2.stopOnFirstError && errors3.length > 0)
           return;
@@ -22298,7 +22299,7 @@ class ConfigValidator {
         for (const requiredProp of schema.required) {
           if (!(requiredProp in obj)) {
             errors3.push({
-              path: path2 ? `${path2}.${requiredProp}` : requiredProp,
+              path: path3 ? `${path3}.${requiredProp}` : requiredProp,
               message: `Missing required property '${requiredProp}'`,
               expected: "required",
               rule: "required"
@@ -22311,7 +22312,7 @@ class ConfigValidator {
       if (schema.properties) {
         for (const [propName, propSchema] of Object.entries(schema.properties)) {
           if (propName in obj) {
-            const propPath = path2 ? `${path2}.${propName}` : propName;
+            const propPath = path3 ? `${path3}.${propName}` : propName;
             this.validateObjectAgainstSchema(obj[propName], propSchema, propPath, errors3, warnings, options2);
             if (options2.stopOnFirstError && errors3.length > 0)
               return;
@@ -22323,7 +22324,7 @@ class ConfigValidator {
         for (const propName of Object.keys(obj)) {
           if (!allowedProps.has(propName)) {
             warnings.push({
-              path: path2 ? `${path2}.${propName}` : propName,
+              path: path3 ? `${path3}.${propName}` : propName,
               message: `Additional property '${propName}' is not allowed`,
               rule: "additionalProperties"
             });
@@ -22357,12 +22358,12 @@ class ConfigValidator {
       warnings
     };
   }
-  validateWithRule(value, rule, path2) {
+  validateWithRule(value, rule, path3) {
     const errors3 = [];
     if (rule.required && (value === undefined || value === null)) {
       errors3.push({
-        path: path2,
-        message: rule.message || `Property '${path2}' is required`,
+        path: path3,
+        message: rule.message || `Property '${path3}' is required`,
         expected: "required",
         rule: "required"
       });
@@ -22375,7 +22376,7 @@ class ConfigValidator {
       const actualType = Array.isArray(value) ? "array" : typeof value;
       if (actualType !== rule.type) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: rule.message || `Expected type ${rule.type}, got ${actualType}`,
           expected: rule.type,
           actual: actualType,
@@ -22387,7 +22388,7 @@ class ConfigValidator {
       const length = Array.isArray(value) ? value.length : typeof value === "string" ? value.length : typeof value === "number" ? value : 0;
       if (length < rule.min) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: rule.message || `Value must be at least ${rule.min}`,
           expected: `>= ${rule.min}`,
           actual: length,
@@ -22399,7 +22400,7 @@ class ConfigValidator {
       const length = Array.isArray(value) ? value.length : typeof value === "string" ? value.length : typeof value === "number" ? value : 0;
       if (length > rule.max) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: rule.message || `Value must not exceed ${rule.max}`,
           expected: `<= ${rule.max}`,
           actual: length,
@@ -22410,7 +22411,7 @@ class ConfigValidator {
     if (rule.pattern && typeof value === "string") {
       if (!rule.pattern.test(value)) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: rule.message || `Value does not match pattern ${rule.pattern}`,
           expected: rule.pattern.toString(),
           actual: value,
@@ -22420,7 +22421,7 @@ class ConfigValidator {
     }
     if (rule.enum && !rule.enum.includes(value)) {
       errors3.push({
-        path: path2,
+        path: path3,
         message: rule.message || `Value must be one of: ${rule.enum.join(", ")}`,
         expected: rule.enum.join(", "),
         actual: value,
@@ -22431,7 +22432,7 @@ class ConfigValidator {
       const customError = rule.validator(value);
       if (customError) {
         errors3.push({
-          path: path2,
+          path: path3,
           message: rule.message || customError,
           rule: "custom"
         });
@@ -22439,10 +22440,10 @@ class ConfigValidator {
     }
     return errors3;
   }
-  getValueByPath(obj, path2) {
-    if (!path2)
+  getValueByPath(obj, path3) {
+    if (!path3)
       return obj;
-    const keys = path2.split(".");
+    const keys = path3.split(".");
     let current = obj;
     for (const key of keys) {
       if (current && typeof current === "object" && key in current) {
@@ -22868,10 +22869,10 @@ async function loadConfig5(options2) {
 function applyEnvVarsToConfig2(name, config4, verbose = false) {
   const _envProcessor = new EnvProcessor;
   const envPrefix = name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  function processConfigLevel(obj, path2 = []) {
+  function processConfigLevel(obj, path3 = []) {
     const result = { ...obj };
     for (const [key, value] of Object.entries(obj)) {
-      const currentPath = [...path2, key];
+      const currentPath = [...path3, key];
       const envKeys = [
         `${envPrefix}_${currentPath.join("_").toUpperCase()}`,
         `${envPrefix}_${currentPath.map((k) => k.toUpperCase()).join("")}`,
@@ -22919,41 +22920,41 @@ var defaultGeneratedDir3 = resolve7(process12.cwd(), "src/generated");
 import { join as join4 } from "path";
 
 // node_modules/env-paths/index.js
-import path2 from "path";
+import path3 from "path";
 import os from "os";
 import process13 from "process";
 var homedir3 = os.homedir();
 var tmpdir = os.tmpdir();
 var { env } = process13;
 var macos = (name) => {
-  const library = path2.join(homedir3, "Library");
+  const library = path3.join(homedir3, "Library");
   return {
-    data: path2.join(library, "Application Support", name),
-    config: path2.join(library, "Preferences", name),
-    cache: path2.join(library, "Caches", name),
-    log: path2.join(library, "Logs", name),
-    temp: path2.join(tmpdir, name)
+    data: path3.join(library, "Application Support", name),
+    config: path3.join(library, "Preferences", name),
+    cache: path3.join(library, "Caches", name),
+    log: path3.join(library, "Logs", name),
+    temp: path3.join(tmpdir, name)
   };
 };
 var windows = (name) => {
-  const appData = env.APPDATA || path2.join(homedir3, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path2.join(homedir3, "AppData", "Local");
+  const appData = env.APPDATA || path3.join(homedir3, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path3.join(homedir3, "AppData", "Local");
   return {
-    data: path2.join(localAppData, name, "Data"),
-    config: path2.join(appData, name, "Config"),
-    cache: path2.join(localAppData, name, "Cache"),
-    log: path2.join(localAppData, name, "Log"),
-    temp: path2.join(tmpdir, name)
+    data: path3.join(localAppData, name, "Data"),
+    config: path3.join(appData, name, "Config"),
+    cache: path3.join(localAppData, name, "Cache"),
+    log: path3.join(localAppData, name, "Log"),
+    temp: path3.join(tmpdir, name)
   };
 };
 var linux = (name) => {
-  const username = path2.basename(homedir3);
+  const username = path3.basename(homedir3);
   return {
-    data: path2.join(env.XDG_DATA_HOME || path2.join(homedir3, ".local", "share"), name),
-    config: path2.join(env.XDG_CONFIG_HOME || path2.join(homedir3, ".config"), name),
-    cache: path2.join(env.XDG_CACHE_HOME || path2.join(homedir3, ".cache"), name),
-    log: path2.join(env.XDG_STATE_HOME || path2.join(homedir3, ".local", "state"), name),
-    temp: path2.join(tmpdir, username, name)
+    data: path3.join(env.XDG_DATA_HOME || path3.join(homedir3, ".local", "share"), name),
+    config: path3.join(env.XDG_CONFIG_HOME || path3.join(homedir3, ".config"), name),
+    cache: path3.join(env.XDG_CACHE_HOME || path3.join(homedir3, ".cache"), name),
+    log: path3.join(env.XDG_STATE_HOME || path3.join(homedir3, ".local", "state"), name),
+    temp: path3.join(tmpdir, username, name)
   };
 };
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -22994,22 +22995,27 @@ async function getPluginConfig(ctx) {
 
 // src/lib/renderers/JsonPromptRenderer.ts
 var createJsonPromptRenderer = () => {
-  const format = "json";
-  const render = (data, rootElement = "root") => {
-    return JSON.stringify({ [rootElement]: data }, null, 2);
-  };
-  return {
-    format,
-    render
+  const renderer = {
+    format: "json",
+    render(args) {
+      return JSON.stringify({ [args.type]: args.data }, null, 2);
+    }
   };
+  return renderer;
 };
 
 // src/lib/xml.ts
 function escapeXml(str2) {
   return String(str2).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
+function mapToObject(map2) {
+  return Object.fromEntries(map2.entries());
+}
 function jsonToXml(json2, rootElement = "root") {
   let xml = `<${rootElement}>`;
+  if (json2 instanceof Map) {
+    return jsonToXml(mapToObject(json2), rootElement);
+  }
   for (const key in json2) {
     if (!Object.hasOwn(json2, key)) {
       continue;
@@ -23022,6 +23028,8 @@ function jsonToXml(json2, rootElement = "root") {
       for (const item of value) {
         xml += jsonToXml(item, key);
       }
+    } else if (value instanceof Map) {
+      xml += jsonToXml(mapToObject(value), key);
     } else if (typeof value === "object" && value !== null) {
       xml += jsonToXml(value, key);
     } else if (value !== undefined && value !== null) {
@@ -23034,21 +23042,174 @@ function jsonToXml(json2, rootElement = "root") {
   return xml;
 }
 
+// src/lib/renderers/resourceMapToArray.ts
+var resourceMapToArray = (resources) => {
+  return Array.from(resources.entries()).map(([relativePath, data]) => ({
+    relativePath,
+    ...data
+  }));
+};
+
 // src/lib/renderers/XmlPromptRenderer.ts
 var createXmlPromptRenderer = () => {
-  const format = "xml";
-  const render = (data, rootElement = "root") => {
-    return jsonToXml(data, rootElement);
+  const prepareSkill = (skill) => {
+    return {
+      ...skill,
+      references: resourceMapToArray(skill.references),
+      scripts: resourceMapToArray(skill.scripts),
+      assets: resourceMapToArray(skill.assets)
+    };
   };
-  return {
-    format,
-    render
+  const prepareResource = (resource) => {
+    return resource;
   };
+  const prepareSearchResult = (result) => {
+    return result;
+  };
+  const renderer = {
+    format: "xml",
+    render(args) {
+      const rootElement = args.type || "root";
+      if (args.type === "Skill") {
+        return jsonToXml(prepareSkill(args.data), rootElement);
+      }
+      if (args.type === "SkillResource") {
+        return jsonToXml(prepareResource(args.data), rootElement);
+      }
+      if (args.type === "SkillSearchResults") {
+        return jsonToXml(prepareSearchResult(args.data), rootElement);
+      }
+      return jsonToXml({}, rootElement);
+    }
+  };
+  return renderer;
 };
 
+// node_modules/dedent/dist/dedent.mjs
+function ownKeys(object2, enumerableOnly) {
+  var keys = Object.keys(object2);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object2);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object2, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1;i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null)
+    return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object")
+      return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+var dedent = createDedent({});
+var dedent_default = dedent;
+function createDedent(options3) {
+  dedent2.withOptions = (newOptions) => createDedent(_objectSpread(_objectSpread({}, options3), newOptions));
+  return dedent2;
+  function dedent2(strings, ...values) {
+    const raw = typeof strings === "string" ? [strings] : strings.raw;
+    const {
+      alignValues = false,
+      escapeSpecialCharacters = Array.isArray(strings),
+      trimWhitespace = true
+    } = options3;
+    let result = "";
+    for (let i = 0;i < raw.length; i++) {
+      let next = raw[i];
+      if (escapeSpecialCharacters) {
+        next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
+      }
+      result += next;
+      if (i < values.length) {
+        const value = alignValues ? alignValue(values[i], result) : values[i];
+        result += value;
+      }
+    }
+    const lines = result.split(`
+`);
+    let mindent = null;
+    for (const l of lines) {
+      const m = l.match(/^(\s+)\S+/);
+      if (m) {
+        const indent = m[1].length;
+        if (!mindent) {
+          mindent = indent;
+        } else {
+          mindent = Math.min(mindent, indent);
+        }
+      }
+    }
+    if (mindent !== null) {
+      const m = mindent;
+      result = lines.map((l) => l[0] === " " || l[0] === "\t" ? l.slice(m) : l).join(`
+`);
+    }
+    if (trimWhitespace) {
+      result = result.trim();
+    }
+    if (escapeSpecialCharacters) {
+      result = result.replace(/\\n/g, `
+`);
+    }
+    if (typeof Bun !== "undefined") {
+      result = result.replace(/\\u(?:\{([\da-fA-F]{1,6})\}|([\da-fA-F]{4}))/g, (_, braced, unbraced) => {
+        var _ref;
+        const hex3 = (_ref = braced !== null && braced !== undefined ? braced : unbraced) !== null && _ref !== undefined ? _ref : "";
+        return String.fromCodePoint(parseInt(hex3, 16));
+      });
+    }
+    return result;
+  }
+}
+function alignValue(value, precedingText) {
+  if (typeof value !== "string" || !value.includes(`
+`)) {
+    return value;
+  }
+  const currentLine = precedingText.slice(precedingText.lastIndexOf(`
+`) + 1);
+  const indentMatch = currentLine.match(/^(\s+)/);
+  if (indentMatch) {
+    const indent = indentMatch[1];
+    return value.replace(/\n/g, `
+${indent}`);
+  }
+  return value;
+}
+
 // src/lib/renderers/MdPromptRenderer.ts
 var createMdPromptRenderer = () => {
-  const format = "md";
   const renderObject = (obj, headingLevel, indentLevel = 0) => {
     const entries = Object.entries(obj);
     let output = "";
@@ -23114,25 +23275,51 @@ var createMdPromptRenderer = () => {
   const htmlEscape = (value) => {
     return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
   };
-  const render = (data, rootElement = "Prompt") => {
-    const { content, ...restData } = data;
-    return `# ${rootElement}
+  const renderSkill = (skill) => {
+    return dedent_default`
+      # ${skill.name}
 
-${renderObject(restData, 3)}
+      ${skill.content}
 
-${content && `---
+      ## Metadata
 
-### Content
+      ${skill.metadata ? renderObject(skill.metadata, 3) : ""}
+ 
+      ## References
 
-${content}
+      ${skill.references ? renderArray(resourceMapToArray(skill.references), 1) : ""}
 
-` || ""}
+      ## Scripts
+
+      ${skill.scripts ? renderArray(resourceMapToArray(skill.scripts), 1) : ""}
+
+      ## Assets
+
+      ${skill.assets ? renderArray(resourceMapToArray(skill.assets), 1) : ""}
     `;
   };
-  return {
-    format,
-    render
+  const renderResource = (resource) => {
+    return renderObject(resource, 3);
+  };
+  const renderSearchResult = (result) => {
+    return renderObject(result, 3);
+  };
+  const renderer = {
+    format: "md",
+    render(args) {
+      if (args.type === "Skill") {
+        return renderSkill(args.data);
+      }
+      if (args.type === "SkillResource") {
+        return renderResource(args.data);
+      }
+      if (args.type === "SkillSearchResults") {
+        return renderSearchResult(args.data);
+      }
+      return renderObject({}, 3);
+    }
   };
+  return renderer;
 };
 
 // src/lib/createPromptRenderer.ts
@@ -23264,7 +23451,7 @@ var SkillsPlugin = async (ctx) => {
           const renderer = promptRenderer.getFormatter(format);
           const results = await api2.loadSkill(args.skill_names);
           for await (const skill of results.loaded) {
-            await sendPrompt(renderer(skill, "Skill"), {
+            await sendPrompt(renderer({ data: skill, type: "Skill" }), {
               sessionId: toolCtx.sessionID
             });
           }
@@ -23290,7 +23477,7 @@ var SkillsPlugin = async (ctx) => {
           });
           const renderer = promptRenderer.getFormatter(format);
           const results = await api2.findSkills(args);
-          const output = renderer(results, "SkillSearchResults");
+          const output = renderer({ data: results, type: "SkillSearchResults" });
           return output;
         }
       }),
@@ -23314,7 +23501,7 @@ var SkillsPlugin = async (ctx) => {
           if (!result.injection) {
             throw new Error("Failed to read resource");
           }
-          await sendPrompt(renderer(result.injection, "Resource"), {
+          await sendPrompt(renderer({ data: result.injection, type: "SkillResource" }), {
             sessionId: toolCtx.sessionID
           });
           return JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenobius/opencode-skillful",
-  "version": "1.2.1",
+  "version": "1.2.2-next.2",
   "description": "OpenCode Skills Plugin - Anthropic Agent Skills Specification implementation",
   "type": "module",
   "module": "src/index.ts",
@@ -21,6 +21,7 @@
   "dependencies": {
     "@opencode-ai/plugin": "1.0.85",
     "bunfig": "^0.15.6",
+    "dedent": "^1.7.1",
     "env-paths": "^3.0.0",
     "gray-matter": "^4.0.3",
     "mime": "^4.1.0",