@fro.bot/systematic 1.2.1 → 1.3.0

package/dist/index.js

@@ -1,69 +1,124 @@
 // @bun
 import {
-  convertContent,
   convertFileWithCache,
   extractAgentFrontmatter,
   extractCommandFrontmatter,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
+  formatSkillsXml,
+  loadConfig,
   stripFrontmatter
-} from "./index-hkk4125w.js";
+} from "./index-ymsavt2y.js";
 
 // src/index.ts
-import fs3 from "fs";
-import os2 from "os";
-import path3 from "path";
+import fs2 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 
-// src/lib/config.ts
+// src/lib/bootstrap.ts
 import fs from "fs";
-import path from "path";
 import os from "os";
-import { parse as parseJsonc } from "jsonc-parser";
-var DEFAULT_CONFIG = {
-  disabled_skills: [],
-  disabled_agents: [],
-  disabled_commands: [],
-  bootstrap: {
-    enabled: true
+import path from "path";
+function getToolMappingTemplate(bundledSkillsDir) {
+  return `**Tool Mapping for OpenCode:**
+When skills reference tools you don't have, substitute OpenCode equivalents:
+- \`TodoWrite\` \u2192 \`update_plan\`
+- \`Task\` tool with subagents \u2192 Use OpenCode's subagent system (@mention)
+- \`Skill\` tool \u2192 OpenCode's native \`skill\` tool
+- \`SystematicSkill\` tool \u2192 \`systematic_skill\` (Systematic plugin skills)
+- \`Read\`, \`Write\`, \`Edit\`, \`Bash\` \u2192 Your native tools
+
+**Skills naming:**
+- Bundled skills use the \`systematic:\` prefix (e.g., \`systematic:brainstorming\`)
+- Skills can also be invoked without prefix if unambiguous
+
+**Skills usage:**
+- Use \`systematic_skill\` to load Systematic bundled skills
+- Use the native \`skill\` tool for non-Systematic skills
+
+**Skills location:**
+Bundled skills are in \`${bundledSkillsDir}/\``;
+}
+function getBootstrapContent(config, deps) {
+  const { bundledSkillsDir } = deps;
+  if (!config.bootstrap.enabled)
+    return null;
+  if (config.bootstrap.file) {
+    const customPath = config.bootstrap.file.startsWith("~/") ? path.join(os.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
+    if (fs.existsSync(customPath)) {
+      return fs.readFileSync(customPath, "utf8");
+    }
   }
-};
-function loadJsoncFile(filePath) {
-  try {
-    if (!fs.existsSync(filePath))
-      return null;
-    const content = fs.readFileSync(filePath, "utf-8");
-    return parseJsonc(content);
-  } catch {
+  const usingSystematicPath = path.join(bundledSkillsDir, "using-systematic/SKILL.md");
+  if (!fs.existsSync(usingSystematicPath))
     return null;
+  const fullContent = fs.readFileSync(usingSystematicPath, "utf8");
+  const content = stripFrontmatter(fullContent);
+  const toolMapping = getToolMappingTemplate(bundledSkillsDir);
+  return `<SYSTEMATIC_WORKFLOWS>
+You have access to structured engineering workflows via the systematic plugin.
+
+**IMPORTANT: The using-systematic skill content is included below. It is ALREADY LOADED - you are currently following it. Do NOT use the systematic_skill tool to load "using-systematic" again - that would be redundant.**
+
+${content}
+
+${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 mergeArraysUnique(arr1, arr2) {
-  const set = new Set;
-  if (arr1)
-    arr1.forEach((item) => set.add(item));
-  if (arr2)
-    arr2.forEach((item) => set.add(item));
-  return Array.from(set);
+function formatSkillDescription(description, fallbackName) {
+  const desc = description || `${fallbackName} skill`;
+  if (desc.startsWith(SKILL_DESCRIPTION_PREFIX)) {
+    return desc;
+  }
+  return `${SKILL_DESCRIPTION_PREFIX}${desc}`;
 }
-function loadConfig(projectDir) {
-  const homeDir = os.homedir();
-  const userConfigPath = path.join(homeDir, ".config/opencode/systematic.json");
-  const projectConfigPath = path.join(projectDir, ".opencode/systematic.json");
-  const userConfig = loadJsoncFile(userConfigPath);
-  const projectConfig = loadJsoncFile(projectConfigPath);
-  const result = {
-    disabled_skills: mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_skills, userConfig?.disabled_skills), projectConfig?.disabled_skills),
-    disabled_agents: mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_agents, userConfig?.disabled_agents), projectConfig?.disabled_agents),
-    disabled_commands: mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_commands, userConfig?.disabled_commands), projectConfig?.disabled_commands),
-    bootstrap: {
-      ...DEFAULT_CONFIG.bootstrap,
-      ...userConfig?.bootstrap,
-      ...projectConfig?.bootstrap
-    }
-  };
-  return result;
+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
@@ -84,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 {
@@ -95,20 +152,15 @@ 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, sourceType, disabledAgents) {
+function collectAgents(dir, disabledAgents) {
   const agents = {};
-  const agentList = findAgentsInDir(dir, sourceType);
+  const agentList = findAgentsInDir(dir);
   for (const agentInfo of agentList) {
     if (disabledAgents.includes(agentInfo.name))
       continue;
@@ -119,9 +171,9 @@ function collectAgents(dir, sourceType, disabledAgents) {
   }
   return agents;
 }
-function collectCommands(dir, sourceType, disabledCommands) {
+function collectCommands(dir, disabledCommands) {
   const commands = {};
-  const commandList = findCommandsInDir(dir, sourceType);
+  const commandList = findCommandsInDir(dir);
   for (const commandInfo of commandList) {
     const cleanName = commandInfo.name.replace(/^\//, "");
     if (disabledCommands.includes(cleanName))
@@ -133,15 +185,15 @@ function collectCommands(dir, sourceType, disabledCommands) {
   }
   return commands;
 }
-function collectSkillsAsCommands(dir, sourceType, disabledSkills) {
+function collectSkillsAsCommands(dir, disabledSkills) {
   const commands = {};
-  const skillList = findSkillsInDir(dir, sourceType, 3);
+  const skillList = findSkillsInDir(dir);
   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;
@@ -150,9 +202,9 @@ function createConfigHandler(deps) {
   const { directory, bundledSkillsDir, bundledAgentsDir, bundledCommandsDir } = deps;
   return async (config) => {
     const systematicConfig = loadConfig(directory);
-    const bundledAgents = collectAgents(bundledAgentsDir, "bundled", systematicConfig.disabled_agents);
-    const bundledCommands = collectCommands(bundledCommandsDir, "bundled", systematicConfig.disabled_commands);
-    const bundledSkills = collectSkillsAsCommands(bundledSkillsDir, "bundled", systematicConfig.disabled_skills);
+    const bundledAgents = collectAgents(bundledAgentsDir, systematicConfig.disabled_agents);
+    const bundledCommands = collectCommands(bundledCommandsDir, systematicConfig.disabled_commands);
+    const bundledSkills = collectSkillsAsCommands(bundledSkillsDir, systematicConfig.disabled_skills);
     const existingAgents = config.agent ?? {};
     config.agent = {
       ...bundledAgents,
@@ -168,92 +220,32 @@ 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";
-var HOOK_KEY = "systematic_skill_tool_hooked";
-var SYSTEMATIC_MARKER = "__systematic_skill_tool__";
-var globalStore = globalThis;
-function getHookState() {
-  let state = globalStore[HOOK_KEY];
-  if (state == null) {
-    state = {
-      hookedTool: null,
-      hookedDescription: null,
-      initialized: false
-    };
-    globalStore[HOOK_KEY] = state;
-  }
-  return state;
-}
-function getHookedTool() {
-  return getHookState().hookedTool;
-}
-function formatSkillsXml(skills) {
-  if (skills.length === 0)
-    return "";
-  const skillsXml = skills.map((skill) => {
-    const lines = [
-      "  <skill>",
-      `    <name>systematic:${skill.name}</name>`,
-      `    <description>${skill.description}</description>`
-    ];
-    lines.push("  </skill>");
-    return lines.join(`
-`);
-  }).join(`
-`);
-  return `<available_skills>
-${skillsXml}
-</available_skills>`;
-}
-function mergeDescriptions(baseDescription, hookedDescription, systematicSkillsXml) {
-  if (hookedDescription == null || hookedDescription.trim() === "") {
-    return `${baseDescription}
-
-${systematicSkillsXml}`;
-  }
-  const availableSkillsMatch = hookedDescription.match(/<available_skills>([\s\S]*?)<\/available_skills>/);
-  if (availableSkillsMatch) {
-    const existingSkillsContent = availableSkillsMatch[1];
-    const systematicSkillsContent = systematicSkillsXml.replace("<available_skills>", "").replace("</available_skills>", "").trim();
-    const mergedContent = `<available_skills>
-${systematicSkillsContent}
-${existingSkillsContent}</available_skills>`;
-    return hookedDescription.replace(/<available_skills>[\s\S]*?<\/available_skills>/, mergedContent);
-  }
-  return `${hookedDescription}
-
-${systematicSkillsXml}`;
-}
-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, "bundled", 3).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.
 Use this when a task matches an available skill's description.`;
-    const hookState = getHookState();
-    return mergeDescriptions(baseDescription, hookState.hookedDescription, systematicXml);
+    return `${baseDescription}
+
+${systematicXml}`;
   };
   let cachedDescription = null;
-  const toolDef = tool({
+  return tool({
     get description() {
       if (cachedDescription == null) {
         cachedDescription = buildDescription();
@@ -269,98 +261,39 @@ Use this when a task matches an available skill's description.`;
       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}`);
-        }
-      }
-      const hookedTool = getHookedTool();
-      if (hookedTool != null && typeof hookedTool.execute === "function") {
-        try {
-          return await hookedTool.execute(args);
-        } catch {}
+${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(", ")}`);
     }
   });
-  Object.defineProperty(toolDef, SYSTEMATIC_MARKER, {
-    value: true,
-    enumerable: false,
-    writable: false
-  });
-  return toolDef;
 }
 
 // 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 {
     return "unknown";
   }
 };
-var getBootstrapContent = (config) => {
-  if (!config.bootstrap.enabled)
-    return null;
-  if (config.bootstrap.file) {
-    const customPath = config.bootstrap.file.startsWith("~/") ? path3.join(os2.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
-    if (fs3.existsSync(customPath)) {
-      return fs3.readFileSync(customPath, "utf8");
-    }
-  }
-  const usingSystematicPath = path3.join(bundledSkillsDir, "using-systematic/SKILL.md");
-  if (!fs3.existsSync(usingSystematicPath))
-    return null;
-  const fullContent = fs3.readFileSync(usingSystematicPath, "utf8");
-  const content = stripFrontmatter(fullContent);
-  const toolMapping = `**Tool Mapping for OpenCode:**
-When skills reference tools you don't have, substitute OpenCode equivalents:
-- \`TodoWrite\` \u2192 \`update_plan\`
-- \`Task\` tool with subagents \u2192 Use OpenCode's subagent system (@mention)
-- \`Skill\` tool \u2192 OpenCode's native \`skill\` tool
-- \`SystematicSkill\` tool \u2192 \`systematic_skill\` (Systematic plugin skills)
-- \`Read\`, \`Write\`, \`Edit\`, \`Bash\` \u2192 Your native tools
-
-**Skills naming:**
-- Bundled skills use the \`systematic:\` prefix (e.g., \`systematic:brainstorming\`)
-- Skills can also be invoked without prefix if unambiguous
-
-**Skills usage:**
-- Use \`systematic_skill\` to load Systematic bundled skills
-- Use the native \`skill\` tool for non-Systematic skills
-
-**Skills location:**
-Bundled skills are in \`${bundledSkillsDir}/\``;
-  return `<SYSTEMATIC_WORKFLOWS>
-You have access to structured engineering workflows via the systematic plugin.
-
-**IMPORTANT: The using-systematic skill content is included below. It is ALREADY LOADED - you are currently following it. Do NOT use the systematic_skill tool to load "using-systematic" again - that would be redundant.**
-
-${content}
-
-${toolMapping}
-</SYSTEMATIC_WORKFLOWS>`;
-};
 var SystematicPlugin = async ({ client, directory }) => {
   const config = loadConfig(directory);
   const configHandler = createConfigHandler({
@@ -403,7 +336,7 @@ var SystematicPlugin = async ({ client, directory }) => {
       if (existingSystem.includes("title generator") || existingSystem.includes("generate a title")) {
         return;
       }
-      const content = getBootstrapContent(config);
+      const content = getBootstrapContent(config, { bundledSkillsDir });
       if (content) {
         if (!output.system) {
           output.system = [];

package/dist/lib/agents.d.ts

@@ -0,0 +1,12 @@
+export interface AgentFrontmatter {
+    name: string;
+    description: string;
+    prompt: string;
+}
+export interface AgentInfo {
+    name: string;
+    file: string;
+    category?: string;
+}
+export declare function findAgentsInDir(dir: string, maxDepth?: number): AgentInfo[];
+export declare function extractAgentFrontmatter(content: string): AgentFrontmatter;

package/dist/lib/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import type { SystematicConfig } from './config.js';
+export interface BootstrapDeps {
+    bundledSkillsDir: string;
+}
+export declare function getBootstrapContent(config: SystematicConfig, deps: BootstrapDeps): string | null;

package/dist/lib/commands.d.ts

@@ -0,0 +1,12 @@
+export interface CommandFrontmatter {
+    name: string;
+    description: string;
+    argumentHint: string;
+}
+export interface CommandInfo {
+    name: string;
+    file: string;
+    category?: string;
+}
+export declare function findCommandsInDir(dir: string, maxDepth?: number): CommandInfo[];
+export declare function extractCommandFrontmatter(content: string): CommandFrontmatter;

package/dist/lib/config-handler.d.ts

@@ -0,0 +1,17 @@
+import type { Config } from '@opencode-ai/sdk';
+export interface ConfigHandlerDeps {
+    directory: string;
+    bundledSkillsDir: string;
+    bundledAgentsDir: string;
+    bundledCommandsDir: string;
+}
+/**
+ * Create the config hook handler for the Systematic plugin.
+ *
+ * This follows the pattern used by oh-my-opencode to inject bundled agents,
+ * skills (as commands), and commands into OpenCode's configuration.
+ *
+ * Only bundled content is loaded. User/project overrides are not supported.
+ * Existing OpenCode config is preserved and takes precedence.
+ */
+export declare function createConfigHandler(deps: ConfigHandlerDeps): (config: Config) => Promise<void>;

package/dist/lib/config.d.ts

@@ -0,0 +1,18 @@
+export interface BootstrapConfig {
+    enabled: boolean;
+    file?: string;
+}
+export interface SystematicConfig {
+    disabled_skills: string[];
+    disabled_agents: string[];
+    disabled_commands: string[];
+    bootstrap: BootstrapConfig;
+}
+export declare const DEFAULT_CONFIG: SystematicConfig;
+export declare function loadConfig(projectDir: string): SystematicConfig;
+export declare function getConfigPaths(projectDir: string): {
+    userConfig: string;
+    projectConfig: string;
+    userDir: string;
+    projectDir: string;
+};

package/dist/lib/converter.d.ts

@@ -0,0 +1,12 @@
+export type ContentType = 'skill' | 'agent' | 'command';
+export type SourceType = 'bundled' | 'external';
+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;
+export declare function clearConverterCache(): void;

package/dist/lib/frontmatter.d.ts

@@ -0,0 +1,18 @@
+export interface FrontmatterResult<T = Record<string, unknown>> {
+    data: T;
+    body: string;
+    hadFrontmatter: boolean;
+    parseError: boolean;
+}
+/**
+ * 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/dist/lib/skill-tool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from '@opencode-ai/plugin';
+export interface SkillToolOptions {
+    bundledSkillsDir: string;
+    disabledSkills: string[];
+}
+export declare function createSkillTool(options: SkillToolOptions): ToolDefinition;

package/dist/lib/skills.d.ts

@@ -0,0 +1,13 @@
+export interface SkillFrontmatter {
+    name: string;
+    description: string;
+}
+export interface SkillInfo {
+    path: string;
+    skillFile: string;
+    name: string;
+    description: string;
+}
+export declare function extractFrontmatter(filePath: string): SkillFrontmatter;
+export declare function findSkillsInDir(dir: string, maxDepth?: number): SkillInfo[];
+export declare function formatSkillsXml(skills: SkillInfo[]): string;

package/dist/lib/walk-dir.d.ts

@@ -0,0 +1,12 @@
+export interface WalkEntry {
+    path: string;
+    name: string;
+    isDirectory: boolean;
+    depth: number;
+    category?: string;
+}
+export interface WalkOptions {
+    maxDepth?: number;
+    filter?: (entry: WalkEntry) => boolean;
+}
+export declare function walkDir(rootDir: string, options?: WalkOptions): WalkEntry[];