opencode-dynamic-skills 1.0.1 → 1.0.2

package/dist/index.js

@@ -17839,6 +17839,18 @@ function createResourceCandidates(type, relativePath) {
 function normalizeSkillIdentifier(identifier) {
   return identifier.trim().toLowerCase().replace(/[/-]/g, "_");
 }
+function resolveFileWithinSkillRoot(skill, relativePath) {
+  const normalizedPath = normalizeSkillResourcePath(relativePath);
+  const absolutePath = path.resolve(skill.fullPath, normalizedPath);
+  const relativeFromSkillRoot = path.relative(skill.fullPath, absolutePath);
+  if (relativeFromSkillRoot.startsWith("..") || path.isAbsolute(relativeFromSkillRoot) || !doesPathExist(absolutePath)) {
+    return null;
+  }
+  return {
+    absolutePath,
+    mimeType: detectMimeType(absolutePath)
+  };
+}
 function createSkillResourceResolver(provider) {
   return async (args) => {
     const skillIdentifier = normalizeSkillIdentifier(args.skill_name);
@@ -17849,18 +17861,19 @@ function createSkillResourceResolver(provider) {
     const resourceMap = getSkillResources(skill);
     const candidatePaths = createResourceCandidates(args.type, args.relative_path);
     const resourceEntry = candidatePaths.map((candidatePath) => resourceMap.get(candidatePath)).find((candidate) => candidate !== undefined);
-    if (!resourceEntry) {
+    const resolvedResource = resourceEntry ?? candidatePaths.map((candidatePath) => resolveFileWithinSkillRoot(skill, candidatePath)).find((candidate) => candidate !== null);
+    if (!resolvedResource) {
       throw new Error(`Resource not found: Skill "${args.skill_name}" does not have a resource at path "${args.relative_path}"`);
     }
     try {
-      const content = await readSkillFile(resourceEntry.absolutePath);
+      const content = await readSkillFile(resolvedResource.absolutePath);
       return {
-        absolute_path: resourceEntry.absolutePath,
+        absolute_path: resolvedResource.absolutePath,
         content,
-        mimeType: resourceEntry.mimeType
+        mimeType: resolvedResource.mimeType
       };
     } catch (error45) {
-      throw new Error(`Failed to read resource at ${resourceEntry.absolutePath}: ${error45 instanceof Error ? error45.message : String(error45)}`);
+      throw new Error(`Failed to read resource at ${resolvedResource.absolutePath}: ${error45 instanceof Error ? error45.message : String(error45)}`);
     }
   };
 }
@@ -23207,11 +23220,57 @@ async function rewriteSlashCommandText(args) {
   });
 }
 
+// src/lib/SkillLinks.ts
+import path2 from "path";
+var SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*:/i;
+function normalizeLinkedSkillPath(target) {
+  const trimmedTarget = target.trim();
+  if (trimmedTarget.length === 0 || trimmedTarget.startsWith("#") || trimmedTarget.startsWith("/") || SCHEME_PATTERN.test(trimmedTarget)) {
+    return null;
+  }
+  const [pathWithoutFragment] = trimmedTarget.split("#", 1);
+  const [pathWithoutQuery] = pathWithoutFragment.split("?", 1);
+  const normalizedPath = path2.posix.normalize(pathWithoutQuery.replace(/\\/g, "/")).replace(/^\.\//, "");
+  if (normalizedPath.length === 0 || normalizedPath === "." || normalizedPath.startsWith("../") || normalizedPath.includes("/../")) {
+    return null;
+  }
+  return normalizedPath;
+}
+function extractSkillLinks(content) {
+  const links = new Map;
+  for (const match of content.matchAll(/\[([^\]]+)\]\(([^)]+)\)/g)) {
+    const label = match[1]?.trim();
+    const originalPath = match[2]?.trim();
+    if (!label || !originalPath) {
+      continue;
+    }
+    const resourcePath = normalizeLinkedSkillPath(originalPath);
+    if (!resourcePath) {
+      continue;
+    }
+    links.set(`${label}:${resourcePath}`, {
+      label,
+      originalPath,
+      resourcePath
+    });
+  }
+  return Array.from(links.values());
+}
+
 // src/lib/renderers/JsonPromptRenderer.ts
 var createJsonPromptRenderer = () => {
   const renderer = {
     format: "json",
     render(args) {
+      if (args.type === "Skill") {
+        return JSON.stringify({
+          Skill: {
+            ...args.data,
+            linkedResources: extractSkillLinks(args.data.content),
+            skillRootInstruction: "Resolve linked files relative to the skill root and use skill_resource with the exact root-relative path."
+          }
+        }, null, 2);
+      }
       return JSON.stringify({ [args.type]: args.data }, null, 2);
     }
   };
@@ -23269,6 +23328,8 @@ var createXmlPromptRenderer = () => {
   const prepareSkill = (skill) => {
     return {
       ...skill,
+      linkedResources: extractSkillLinks(skill.content),
+      skillRootInstruction: "Resolve linked files relative to the skill root and use skill_resource with the exact root-relative path.",
       references: resourceMapToArray(skill.references),
       scripts: resourceMapToArray(skill.scripts),
       assets: resourceMapToArray(skill.assets)
@@ -23490,6 +23551,7 @@ var createMdPromptRenderer = () => {
     return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
   };
   const renderSkill = (skill) => {
+    const linkedResources = extractSkillLinks(skill.content);
     return dedent_default`
       # ${skill.name}
 
@@ -23497,6 +23559,14 @@ var createMdPromptRenderer = () => {
       > ${skill.fullPath}
 
       Relative file references in this skill resolve from the skill root directory.
+      Always use skill_resource with the exact root-relative path for linked files.
+
+      ${linkedResources.length > 0 ? dedent_default`
+            ## Linked files detected in skill content
+
+            ${linkedResources.map((link) => `- [${link.label}](${link.originalPath}) \u2192 use skill_resource with ${link.resourcePath}`).join(`
+`)}
+          ` : ""}
 
       ${skill.content}
 

package/dist/lib/SkillLinks.d.ts

@@ -0,0 +1,7 @@
+export type SkillLink = {
+    label: string;
+    originalPath: string;
+    resourcePath: string;
+};
+export declare function normalizeLinkedSkillPath(target: string): string | null;
+export declare function extractSkillLinks(content: string): SkillLink[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-dynamic-skills",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "OpenCode plugin for dynamic skill loading, slash skill commands, and skill-root-relative resources",
   "homepage": "https://github.com/Wu-H-Y/opencode-dynamic-skills#readme",
   "bugs": {