@fro.bot/systematic 1.2.2 → 1.3.0

package/dist/cli.js

@@ -6,7 +6,7 @@ import {
   findCommandsInDir,
   findSkillsInDir,
   getConfigPaths
-} from "./index-hvkf19rd.js";
+} from "./index-ymsavt2y.js";
 
 // src/cli.ts
 import fs from "fs";

package/dist/{index-hvkf19rd.js → index-ymsavt2y.js}

@@ -1,8 +1,8 @@
 // @bun
 // src/lib/config.ts
 import fs from "fs";
-import path from "path";
 import os from "os";
+import path from "path";
 import { parse as parseJsonc } from "jsonc-parser";
 var DEFAULT_CONFIG = {
   disabled_skills: [],
@@ -25,9 +25,11 @@ function loadJsoncFile(filePath) {
 function mergeArraysUnique(arr1, arr2) {
   const set = new Set;
   if (arr1)
-    arr1.forEach((item) => set.add(item));
+    for (const item of arr1)
+      set.add(item);
   if (arr2)
-    arr2.forEach((item) => set.add(item));
+    for (const item of arr2)
+      set.add(item);
   return Array.from(set);
 }
 function loadConfig(projectDir) {
@@ -58,81 +60,168 @@ function getConfigPaths(projectDir) {
   };
 }
 
-// src/lib/converter.ts
-import fs2 from "fs";
-
 // src/lib/frontmatter.ts
+import yaml from "js-yaml";
 function parseFrontmatter(content) {
-  const lines = content.split(/\r?\n/);
-  if (lines.length === 0 || lines[0].trim() !== "---") {
-    return { data: {}, body: content, raw: "" };
-  }
-  let endIndex = -1;
-  for (let i = 1;i < lines.length; i++) {
-    if (lines[i].trim() === "---") {
-      endIndex = i;
-      break;
-    }
-  }
-  if (endIndex === -1) {
-    return { data: {}, body: content, raw: "" };
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n?---\r?\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return {
+      data: {},
+      body: content,
+      hadFrontmatter: false,
+      parseError: false
+    };
   }
-  const yamlLines = lines.slice(1, endIndex);
-  const body = lines.slice(endIndex + 1).join(`
-`);
-  const raw = lines.slice(0, endIndex + 1).join(`
-`);
-  const data = {};
-  for (const line of yamlLines) {
-    const match = line.match(/^([\w-]+):\s*(.*)$/);
-    if (match) {
-      const [, key, value] = match;
-      if (value === "true")
-        data[key] = true;
-      else if (value === "false")
-        data[key] = false;
-      else if (/^\d+(\.\d+)?$/.test(value))
-        data[key] = parseFloat(value);
-      else
-        data[key] = value;
-    }
+  const yamlContent = match[1];
+  const body = match[2];
+  try {
+    const parsed = yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA });
+    const data = parsed ?? {};
+    return { data, body, hadFrontmatter: true, parseError: false };
+  } catch {
+    return { data: {}, body, hadFrontmatter: true, parseError: true };
   }
-  return { data, body, raw };
 }
 function formatFrontmatter(data) {
-  const lines = ["---"];
-  for (const [key, value] of Object.entries(data)) {
-    lines.push(`${key}: ${value}`);
+  if (Object.keys(data).length === 0) {
+    return ["---", "---"].join(`
+`);
   }
-  lines.push("---");
-  return lines.join(`
+  const yamlContent = yaml.dump(data, {
+    schema: yaml.JSON_SCHEMA,
+    lineWidth: -1,
+    noRefs: true
+  }).trimEnd();
+  return ["---", yamlContent, "---"].join(`
 `);
 }
 function stripFrontmatter(content) {
-  const lines = content.split(`
-`);
-  let inFrontmatter = false;
-  let frontmatterEnded = false;
-  const contentLines = [];
-  for (const line of lines) {
-    if (line.trim() === "---") {
-      if (inFrontmatter) {
-        frontmatterEnded = true;
-        continue;
+  const { body, hadFrontmatter } = parseFrontmatter(content);
+  return hadFrontmatter ? body.trim() : content.trim();
+}
+
+// src/lib/walk-dir.ts
+import fs2 from "fs";
+import path2 from "path";
+function walkDir(rootDir, options = {}) {
+  const { maxDepth = 3, filter } = options;
+  const results = [];
+  if (!fs2.existsSync(rootDir))
+    return results;
+  function recurse(currentDir, depth, category) {
+    if (depth > maxDepth)
+      return;
+    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(currentDir, entry.name);
+      const walkEntry = {
+        path: fullPath,
+        name: entry.name,
+        isDirectory: entry.isDirectory(),
+        depth,
+        category
+      };
+      if (!filter || filter(walkEntry)) {
+        results.push(walkEntry);
+      }
+      if (entry.isDirectory()) {
+        recurse(fullPath, depth + 1, entry.name);
       }
-      inFrontmatter = true;
-      continue;
-    }
-    if (frontmatterEnded || !inFrontmatter) {
-      contentLines.push(line);
     }
   }
-  return contentLines.join(`
-`).trim();
+  recurse(rootDir, 0);
+  return results;
+}
+
+// src/lib/agents.ts
+function findAgentsInDir(dir, maxDepth = 2) {
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => !e.isDirectory && e.name.endsWith(".md")
+  });
+  return entries.map((entry) => ({
+    name: entry.name.replace(/\.md$/, ""),
+    file: entry.path,
+    category: entry.category
+  }));
+}
+function extractAgentFrontmatter(content) {
+  const { data, parseError } = parseFrontmatter(content);
+  return {
+    name: !parseError && typeof data.name === "string" ? data.name : "",
+    description: !parseError && typeof data.description === "string" ? data.description : "",
+    prompt: stripFrontmatter(content)
+  };
+}
+
+// src/lib/commands.ts
+function findCommandsInDir(dir, maxDepth = 2) {
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => !e.isDirectory && e.name.endsWith(".md")
+  });
+  return entries.map((entry) => {
+    const baseName = entry.name.replace(/\.md$/, "");
+    const commandName = entry.category ? `/${entry.category}:${baseName}` : `/${baseName}`;
+    return {
+      name: commandName,
+      file: entry.path,
+      category: entry.category
+    };
+  });
+}
+function extractCommandFrontmatter(content) {
+  const { data, parseError } = parseFrontmatter(content);
+  const argumentHintRaw = !parseError && typeof data["argument-hint"] === "string" ? data["argument-hint"] : "";
+  return {
+    name: !parseError && typeof data.name === "string" ? data.name : "",
+    description: !parseError && typeof data.description === "string" ? data.description : "",
+    argumentHint: argumentHintRaw.replace(/^["']|["']$/g, "")
+  };
 }
 
 // src/lib/converter.ts
+import fs3 from "fs";
 var cache = new Map;
+var TOOL_MAPPINGS = [
+  [/\bTask\s+tool\b/gi, "delegate_task tool"],
+  [/\bTask\s+([\w-]+)\s*\(/g, "delegate_task $1("],
+  [/\bTask\s*\(/g, "delegate_task("],
+  [/\bTask\b(?=\s+to\s+\w)/g, "delegate_task"],
+  [/\bTodoWrite\b/g, "todowrite"],
+  [/\bAskUserQuestion\b/g, "question"],
+  [/\bWebSearch\b/g, "google_search"],
+  [/\bRead\b(?=\s+tool|\s+to\s+|\()/g, "read"],
+  [/\bWrite\b(?=\s+tool|\s+to\s+|\()/g, "write"],
+  [/\bEdit\b(?=\s+tool|\s+to\s+|\()/g, "edit"],
+  [/\bBash\b(?=\s+tool|\s+to\s+|\()/g, "bash"],
+  [/\bGrep\b(?=\s+tool|\s+to\s+|\()/g, "grep"],
+  [/\bGlob\b(?=\s+tool|\s+to\s+|\()/g, "glob"],
+  [/\bWebFetch\b/g, "webfetch"],
+  [/\bSkill\b(?=\s+tool)/g, "skill"]
+];
+var PATH_REPLACEMENTS = [
+  [/\.claude\/skills\//g, ".opencode/skills/"],
+  [/\.claude\/commands\//g, ".opencode/commands/"],
+  [/\.claude\/agents\//g, ".opencode/agents/"],
+  [/~\/\.claude\//g, "~/.config/opencode/"],
+  [/CLAUDE\.md/g, "AGENTS.md"],
+  [/\/compound-engineering:/g, "/systematic:"],
+  [/compound-engineering:/g, "systematic:"]
+];
+var CC_ONLY_SKILL_FIELDS = [
+  "model",
+  "allowed-tools",
+  "allowedTools",
+  "disable-model-invocation",
+  "disableModelInvocation",
+  "user-invocable",
+  "userInvocable",
+  "context",
+  "agent"
+];
+var CC_ONLY_COMMAND_FIELDS = ["argument-hint", "argumentHint"];
 function inferTemperature(name, description) {
   const sample = `${name} ${description ?? ""}`.toLowerCase();
   if (/(review|audit|security|sentinel|oracle|lint|verification|guardian)/.test(sample)) {
@@ -149,6 +238,37 @@ function inferTemperature(name, description) {
   }
   return 0.3;
 }
+function transformBody(body) {
+  let result = body;
+  for (const [pattern, replacement] of TOOL_MAPPINGS) {
+    result = result.replace(pattern, replacement);
+  }
+  for (const [pattern, replacement] of PATH_REPLACEMENTS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+function removeFields(data, fieldsToRemove) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (!fieldsToRemove.includes(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function transformSkillFrontmatter(data) {
+  return removeFields(data, CC_ONLY_SKILL_FIELDS);
+}
+function transformCommandFrontmatter(data) {
+  const cleaned = removeFields(data, CC_ONLY_COMMAND_FIELDS);
+  if (typeof cleaned.model === "string" && cleaned.model !== "inherit") {
+    cleaned.model = normalizeModel(cleaned.model);
+  } else if (cleaned.model === "inherit") {
+    delete cleaned.model;
+  }
+  return cleaned;
+}
 function normalizeModel(model) {
   if (model.includes("/"))
     return model;
@@ -182,153 +302,46 @@ function transformAgentFrontmatter(data, agentMode) {
 function convertContent(content, type, options = {}) {
   if (content === "")
     return "";
-  const { data, body, raw } = parseFrontmatter(content);
-  const hasFrontmatter = raw !== "";
-  if (!hasFrontmatter) {
-    return content;
+  const { data, body, hadFrontmatter } = parseFrontmatter(content);
+  if (!hadFrontmatter) {
+    return options.skipBodyTransform ? content : transformBody(content);
   }
+  const shouldTransformBody = !options.skipBodyTransform;
+  const transformedBody = shouldTransformBody ? transformBody(body) : body;
   if (type === "agent") {
     const agentMode = options.agentMode ?? "subagent";
     const transformedData = transformAgentFrontmatter(data, agentMode);
     return `${formatFrontmatter(transformedData)}
-${body}`;
+${transformedBody}`;
+  }
+  if (type === "skill") {
+    const transformedData = transformSkillFrontmatter(data);
+    return `${formatFrontmatter(transformedData)}
+${transformedBody}`;
+  }
+  if (type === "command") {
+    const transformedData = transformCommandFrontmatter(data);
+    return `${formatFrontmatter(transformedData)}
+${transformedBody}`;
   }
   return content;
 }
 function convertFileWithCache(filePath, type, options = {}) {
-  const fd = fs2.openSync(filePath, "r");
+  const fd = fs3.openSync(filePath, "r");
   try {
-    const stats = fs2.fstatSync(fd);
-    const cacheKey = `${filePath}:${type}:${options.source ?? "bundled"}:${options.agentMode ?? "subagent"}`;
+    const stats = fs3.fstatSync(fd);
+    const cacheKey = `${filePath}:${type}:${options.source ?? "bundled"}:${options.agentMode ?? "subagent"}:${options.skipBodyTransform ?? false}`;
     const cached = cache.get(cacheKey);
     if (cached != null && cached.mtimeMs === stats.mtimeMs) {
       return cached.converted;
     }
-    const content = fs2.readFileSync(fd, "utf8");
+    const content = fs3.readFileSync(fd, "utf8");
     const converted = convertContent(content, type, options);
     cache.set(cacheKey, { mtimeMs: stats.mtimeMs, converted });
     return converted;
   } finally {
-    fs2.closeSync(fd);
-  }
-}
-
-// src/lib/walk-dir.ts
-import fs3 from "fs";
-import path2 from "path";
-function walkDir(rootDir, options = {}) {
-  const { maxDepth = 3, filter } = options;
-  const results = [];
-  if (!fs3.existsSync(rootDir))
-    return results;
-  function recurse(currentDir, depth, category) {
-    if (depth > maxDepth)
-      return;
-    const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path2.join(currentDir, entry.name);
-      const walkEntry = {
-        path: fullPath,
-        name: entry.name,
-        isDirectory: entry.isDirectory(),
-        depth,
-        category
-      };
-      if (!filter || filter(walkEntry)) {
-        results.push(walkEntry);
-      }
-      if (entry.isDirectory()) {
-        recurse(fullPath, depth + 1, entry.name);
-      }
-    }
+    fs3.closeSync(fd);
   }
-  recurse(rootDir, 0);
-  return results;
-}
-
-// src/lib/agents.ts
-function findAgentsInDir(dir, maxDepth = 2) {
-  const entries = walkDir(dir, {
-    maxDepth,
-    filter: (e) => !e.isDirectory && e.name.endsWith(".md")
-  });
-  return entries.map((entry) => ({
-    name: entry.name.replace(/\.md$/, ""),
-    file: entry.path,
-    category: entry.category
-  }));
-}
-function extractAgentFrontmatter(content) {
-  const lines = content.split(`
-`);
-  let inFrontmatter = false;
-  let name = "";
-  let description = "";
-  for (const line of lines) {
-    if (line.trim() === "---") {
-      if (inFrontmatter)
-        break;
-      inFrontmatter = true;
-      continue;
-    }
-    if (inFrontmatter) {
-      const match = line.match(/^(\w+(?:-\w+)*):\s*(.*)$/);
-      if (match) {
-        const [, key, value] = match;
-        if (key === "name")
-          name = value.trim();
-        if (key === "description")
-          description = value.trim();
-      }
-    }
-  }
-  return { name, description, prompt: stripFrontmatter(content) };
-}
-
-// src/lib/commands.ts
-function findCommandsInDir(dir, maxDepth = 2) {
-  const entries = walkDir(dir, {
-    maxDepth,
-    filter: (e) => !e.isDirectory && e.name.endsWith(".md")
-  });
-  return entries.map((entry) => {
-    const baseName = entry.name.replace(/\.md$/, "");
-    const commandName = entry.category ? `/${entry.category}:${baseName}` : `/${baseName}`;
-    return {
-      name: commandName,
-      file: entry.path,
-      category: entry.category
-    };
-  });
-}
-function extractCommandFrontmatter(content) {
-  const lines = content.split(`
-`);
-  let inFrontmatter = false;
-  let name = "";
-  let description = "";
-  let argumentHint = "";
-  for (const line of lines) {
-    if (line.trim() === "---") {
-      if (inFrontmatter)
-        break;
-      inFrontmatter = true;
-      continue;
-    }
-    if (inFrontmatter) {
-      const match = line.match(/^(\w+(?:-\w+)*):\s*(.*)$/);
-      if (match) {
-        const [, key, value] = match;
-        if (key === "name")
-          name = value.trim();
-        if (key === "description")
-          description = value.trim();
-        if (key === "argument-hint")
-          argumentHint = value.trim().replace(/^["']|["']$/g, "");
-      }
-    }
-  }
-  return { name, description, argumentHint };
 }
 
 // src/lib/skills.ts
@@ -337,30 +350,14 @@ import path3 from "path";
 function extractFrontmatter(filePath) {
   try {
     const content = fs4.readFileSync(filePath, "utf8");
-    const lines = content.split(`
-`);
-    let inFrontmatter = false;
-    let name = "";
-    let description = "";
-    for (const line of lines) {
-      if (line.trim() === "---") {
-        if (inFrontmatter)
-          break;
-        inFrontmatter = true;
-        continue;
-      }
-      if (inFrontmatter) {
-        const match = line.match(/^(\w+):\s*(.*)$/);
-        if (match) {
-          const [, key, value] = match;
-          if (key === "name")
-            name = value.trim();
-          if (key === "description")
-            description = value.trim();
-        }
-      }
+    const { data, parseError } = parseFrontmatter(content);
+    if (parseError) {
+      return { name: "", description: "" };
     }
-    return { name, description };
+    return {
+      name: typeof data.name === "string" ? data.name : "",
+      description: typeof data.description === "string" ? data.description : ""
+    };
   } catch {
     return { name: "", description: "" };
   }
@@ -404,4 +401,4 @@ ${skillsXml}
 </available_skills>`;
 }
 
-export { stripFrontmatter, loadConfig, getConfigPaths, convertContent, convertFileWithCache, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter, findSkillsInDir, formatSkillsXml };
+export { stripFrontmatter, loadConfig, getConfigPaths, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter, convertContent, convertFileWithCache, findSkillsInDir, formatSkillsXml };

package/dist/index.js

@@ -1,6 +1,5 @@
 // @bun
 import {
-  convertContent,
   convertFileWithCache,
   extractAgentFrontmatter,
   extractCommandFrontmatter,
@@ -10,11 +9,11 @@ import {
   formatSkillsXml,
   loadConfig,
   stripFrontmatter
-} from "./index-hvkf19rd.js";
+} from "./index-ymsavt2y.js";
 
 // src/index.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/bootstrap.ts
@@ -68,6 +67,60 @@ ${toolMapping}
 </SYSTEMATIC_WORKFLOWS>`;
 }
 
+// src/lib/skill-loader.ts
+import path2 from "path";
+var SKILL_PREFIX = "systematic:";
+var SKILL_DESCRIPTION_PREFIX = "(systematic - Skill) ";
+function formatSkillCommandName(name) {
+  if (name.startsWith(SKILL_PREFIX)) {
+    return name;
+  }
+  return `${SKILL_PREFIX}${name}`;
+}
+function formatSkillDescription(description, fallbackName) {
+  const desc = description || `${fallbackName} skill`;
+  if (desc.startsWith(SKILL_DESCRIPTION_PREFIX)) {
+    return desc;
+  }
+  return `${SKILL_DESCRIPTION_PREFIX}${desc}`;
+}
+function wrapSkillTemplate(skillPath, body) {
+  const skillDir = path2.dirname(skillPath);
+  return `<skill-instruction>
+Base directory for this skill: ${skillDir}/
+File references (@path) in this skill are relative to this directory.
+
+${body.trim()}
+</skill-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
+}
+function extractSkillBody(wrappedTemplate) {
+  const match = wrappedTemplate.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
+  return match ? match[1].trim() : wrappedTemplate;
+}
+function loadSkill(skillInfo) {
+  try {
+    const converted = convertFileWithCache(skillInfo.skillFile, "skill", {
+      source: "bundled"
+    });
+    const body = stripFrontmatter(converted);
+    const wrappedTemplate = wrapSkillTemplate(skillInfo.skillFile, body);
+    return {
+      name: skillInfo.name,
+      prefixedName: formatSkillCommandName(skillInfo.name),
+      description: formatSkillDescription(skillInfo.description, skillInfo.name),
+      path: skillInfo.path,
+      skillFile: skillInfo.skillFile,
+      wrappedTemplate
+    };
+  } catch {
+    return null;
+  }
+}
+
 // src/lib/config-handler.ts
 function loadAgentAsConfig(agentInfo) {
   try {
@@ -86,7 +139,9 @@ function loadAgentAsConfig(agentInfo) {
 }
 function loadCommandAsConfig(commandInfo) {
   try {
-    const converted = convertFileWithCache(commandInfo.file, "command", { source: "bundled" });
+    const converted = convertFileWithCache(commandInfo.file, "command", {
+      source: "bundled"
+    });
     const { name, description } = extractCommandFrontmatter(converted);
     const cleanName = commandInfo.name.replace(/^\//, "");
     return {
@@ -97,16 +152,11 @@ function loadCommandAsConfig(commandInfo) {
     return null;
   }
 }
-function loadSkillAsCommand(skillInfo) {
-  try {
-    const converted = convertFileWithCache(skillInfo.skillFile, "skill", { source: "bundled" });
-    return {
-      template: stripFrontmatter(converted),
-      description: skillInfo.description || `${skillInfo.name} skill`
-    };
-  } catch {
-    return null;
-  }
+function loadSkillAsCommand(loaded) {
+  return {
+    template: loaded.wrappedTemplate,
+    description: loaded.description
+  };
 }
 function collectAgents(dir, disabledAgents) {
   const agents = {};
@@ -141,9 +191,9 @@ function collectSkillsAsCommands(dir, disabledSkills) {
   for (const skillInfo of skillList) {
     if (disabledSkills.includes(skillInfo.name))
       continue;
-    const config = loadSkillAsCommand(skillInfo);
-    if (config) {
-      commands[skillInfo.name] = config;
+    const loaded = loadSkill(skillInfo);
+    if (loaded) {
+      commands[loaded.prefixedName] = loadSkillAsCommand(loaded);
     }
   }
   return commands;
@@ -170,28 +220,22 @@ function createConfigHandler(deps) {
 }
 
 // src/lib/skill-tool.ts
-import fs2 from "fs";
-import path2 from "path";
+import path3 from "path";
 import { tool } from "@opencode-ai/plugin/tool";
-function wrapSkillContent(skillPath, content) {
-  const skillDir = path2.dirname(skillPath);
-  const converted = convertContent(content, "skill", { source: "bundled" });
-  const body = stripFrontmatter(converted);
-  return `<skill-instruction>
-Base directory for this skill: ${skillDir}/
-File references (@path) in this skill are relative to this directory.
-
-${body.trim()}
-</skill-instruction>`;
-}
 function createSkillTool(options) {
   const { bundledSkillsDir, disabledSkills } = options;
   const getSystematicSkills = () => {
-    return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).sort((a, b) => a.name.localeCompare(b.name));
+    return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).map((skillInfo) => loadSkill(skillInfo)).filter((s) => s !== null).sort((a, b) => a.name.localeCompare(b.name));
   };
   const buildDescription = () => {
     const skills = getSystematicSkills();
-    const systematicXml = formatSkillsXml(skills);
+    const skillInfos = skills.map((s) => ({
+      name: s.name,
+      description: s.description,
+      path: s.path,
+      skillFile: s.skillFile
+    }));
+    const systematicXml = formatSkillsXml(skillInfos);
     const baseDescription = `Load a skill to get detailed instructions for a specific task.
 
 Skills provide specialized knowledge and step-by-step guidance.
@@ -217,38 +261,33 @@ ${systematicXml}`;
       const skills = getSystematicSkills();
       const matchedSkill = skills.find((s) => s.name === normalizedName);
       if (matchedSkill) {
-        try {
-          const content = fs2.readFileSync(matchedSkill.skillFile, "utf8");
-          const wrapped = wrapSkillContent(matchedSkill.skillFile, content);
-          return `## Skill: systematic:${matchedSkill.name}
+        const body = extractSkillBody(matchedSkill.wrappedTemplate);
+        const dir = path3.dirname(matchedSkill.skillFile);
+        return `## Skill: ${matchedSkill.prefixedName}
 
-**Base directory**: ${matchedSkill.path}
+**Base directory**: ${dir}
 
-${wrapped}`;
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          throw new Error(`Failed to load skill "${requestedName}": ${errorMessage}`);
-        }
+${body}`;
       }
-      const availableSystematic = skills.map((s) => `systematic:${s.name}`);
+      const availableSystematic = skills.map((s) => s.prefixedName);
       throw new Error(`Skill "${requestedName}" not found. Available systematic skills: ${availableSystematic.join(", ")}`);
     }
   });
 }
 
 // src/index.ts
-var __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
-var packageRoot = path3.resolve(__dirname2, "..");
-var bundledSkillsDir = path3.join(packageRoot, "skills");
-var bundledAgentsDir = path3.join(packageRoot, "agents");
-var bundledCommandsDir = path3.join(packageRoot, "commands");
-var packageJsonPath = path3.join(packageRoot, "package.json");
+var __dirname2 = path4.dirname(fileURLToPath(import.meta.url));
+var packageRoot = path4.resolve(__dirname2, "..");
+var bundledSkillsDir = path4.join(packageRoot, "skills");
+var bundledAgentsDir = path4.join(packageRoot, "agents");
+var bundledCommandsDir = path4.join(packageRoot, "commands");
+var packageJsonPath = path4.join(packageRoot, "package.json");
 var hasLoggedInit = false;
 var getPackageVersion = () => {
   try {
-    if (!fs3.existsSync(packageJsonPath))
+    if (!fs2.existsSync(packageJsonPath))
       return "unknown";
-    const content = fs3.readFileSync(packageJsonPath, "utf8");
+    const content = fs2.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(content);
     return parsed.version ?? "unknown";
   } catch {

package/dist/lib/converter.d.ts

@@ -4,6 +4,8 @@ export type AgentMode = 'primary' | 'subagent';
 export interface ConvertOptions {
     source?: SourceType;
     agentMode?: AgentMode;
+    /** Skip body content transformations (tool names, paths, etc.) */
+    skipBodyTransform?: boolean;
 }
 export declare function convertContent(content: string, type: ContentType, options?: ConvertOptions): string;
 export declare function convertFileWithCache(filePath: string, type: ContentType, options?: ConvertOptions): string;

package/dist/lib/frontmatter.d.ts

@@ -1,9 +1,18 @@
-interface ParsedFrontmatter {
-    data: Record<string, string | number | boolean>;
+export interface FrontmatterResult<T = Record<string, unknown>> {
+    data: T;
     body: string;
-    raw: string;
+    hadFrontmatter: boolean;
+    parseError: boolean;
 }
-export type { ParsedFrontmatter };
-export declare function parseFrontmatter(content: string): ParsedFrontmatter;
-export declare function formatFrontmatter(data: Record<string, string | number | boolean>): string;
+/**
+ * Parses YAML frontmatter from Markdown content.
+ *
+ * Uses js-yaml with JSON_SCHEMA for security (prevents code execution via YAML tags).
+ * Supports all standard YAML keys including hyphenated ones (e.g., 'argument-hint').
+ *
+ * @param content - Markdown content with optional frontmatter
+ * @returns Parsed frontmatter data, body content, and parsing status
+ */
+export declare function parseFrontmatter<T = Record<string, unknown>>(content: string): FrontmatterResult<T>;
+export declare function formatFrontmatter(data: Record<string, unknown>): string;
 export declare function stripFrontmatter(content: string): string;

package/dist/lib/skill-loader.d.ts

@@ -0,0 +1,14 @@
+import type { SkillInfo } from './skills.js';
+export interface LoadedSkill {
+    name: string;
+    prefixedName: string;
+    description: string;
+    path: string;
+    skillFile: string;
+    wrappedTemplate: string;
+}
+export declare function formatSkillCommandName(name: string): string;
+export declare function formatSkillDescription(description: string, fallbackName: string): string;
+export declare function wrapSkillTemplate(skillPath: string, body: string): string;
+export declare function extractSkillBody(wrappedTemplate: string): string;
+export declare function loadSkill(skillInfo: SkillInfo): LoadedSkill | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,6 +54,7 @@
     "@biomejs/biome": "^2.0.0",
     "@opencode-ai/plugin": "^1.1.30",
     "@types/bun": "latest",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "conventional-changelog-conventionalcommits": "^9.0.0",
     "markdownlint-cli": "^0.47.0",
@@ -63,6 +64,7 @@
     "typescript": "^5.7.0"
   },
   "dependencies": {
+    "js-yaml": "^4.1.1",
     "jsonc-parser": "^3.3.0"
   },
   "publishConfig": {