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

package/dist/index.js

@@ -22994,14 +22994,13 @@ 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
@@ -23042,21 +23041,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 = "";
@@ -23122,25 +23274,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}
+
+      ${skill.content}
 
-${renderObject(restData, 3)}
+      ## Metadata
 
-${content && `---
+      ${skill.metadata ? renderObject(skill.metadata, 3) : ""}
+ 
+      ## References
 
-### Content
+      ${skill.references ? renderArray(resourceMapToArray(skill.references), 1) : ""}
 
-${content}
+      ## 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
@@ -23272,7 +23450,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
             });
           }
@@ -23298,7 +23476,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;
         }
       }),
@@ -23322,7 +23500,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-next.1",
+  "version": "1.2.1-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",