@fro.bot/systematic 1.2.1 → 1.2.2

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -4,8 +4,9 @@ import {
   convertContent,
   findAgentsInDir,
   findCommandsInDir,
-  findSkillsInDir
-} from "./index-hkk4125w.js";
+  findSkillsInDir,
+  getConfigPaths
+} from "./index-hvkf19rd.js";
 
 // src/cli.ts
 import fs from "fs";
@@ -37,12 +38,6 @@ Examples:
   systematic convert skill ./skills/my-skill/SKILL.md
   systematic config show
 `;
-function getUserConfigDir() {
-  return path.join(process.env.HOME || process.env.USERPROFILE || ".", ".config/opencode");
-}
-function getProjectConfigDir() {
-  return path.join(process.cwd(), ".opencode");
-}
 function listItems(type) {
   const packageRoot = path.resolve(import.meta.dirname, "..");
   const bundledDir = packageRoot;
@@ -65,7 +60,7 @@ function listItems(type) {
       console.error(`Unknown type: ${type}. Use: skills, agents, commands`);
       process.exit(1);
   }
-  const items = finder(path.join(bundledDir, subdir), "bundled");
+  const items = finder(path.join(bundledDir, subdir));
   if (items.length === 0) {
     console.log(`No ${type} found.`);
     return;
@@ -73,7 +68,7 @@ function listItems(type) {
   console.log(`Available ${type}:
 `);
   for (const item of items.sort((a, b) => a.name.localeCompare(b.name))) {
-    console.log(`  ${item.name} (${item.sourceType})`);
+    console.log(`  ${item.name}`);
   }
 }
 function runConvert(type, filePath, modeArg) {
@@ -102,31 +97,27 @@ function runConvert(type, filePath, modeArg) {
   console.log(converted);
 }
 function configShow() {
-  const userDir = getUserConfigDir();
-  const projectDir = getProjectConfigDir();
+  const paths = getConfigPaths(process.cwd());
   console.log(`Configuration locations:
 `);
-  console.log(`  User config:    ${path.join(userDir, "systematic.json")}`);
-  console.log(`  Project config: ${path.join(projectDir, "systematic.json")}`);
-  const projectConfig = path.join(projectDir, "systematic.json");
-  if (fs.existsSync(projectConfig)) {
+  console.log(`  User config:    ${paths.userConfig}`);
+  console.log(`  Project config: ${paths.projectConfig}`);
+  if (fs.existsSync(paths.projectConfig)) {
     console.log(`
 Project configuration:`);
-    console.log(fs.readFileSync(projectConfig, "utf-8"));
+    console.log(fs.readFileSync(paths.projectConfig, "utf-8"));
   }
-  const userConfig = path.join(userDir, "systematic.json");
-  if (fs.existsSync(userConfig)) {
+  if (fs.existsSync(paths.userConfig)) {
     console.log(`
 User configuration:`);
-    console.log(fs.readFileSync(userConfig, "utf-8"));
+    console.log(fs.readFileSync(paths.userConfig, "utf-8"));
   }
 }
 function configPath() {
-  const userDir = getUserConfigDir();
-  const projectDir = getProjectConfigDir();
+  const paths = getConfigPaths(process.cwd());
   console.log("Config file paths:");
-  console.log(`  User:    ${path.join(userDir, "systematic.json")}`);
-  console.log(`  Project: ${path.join(projectDir, "systematic.json")}`);
+  console.log(`  User:    ${paths.userConfig}`);
+  console.log(`  Project: ${paths.projectConfig}`);
 }
 var args = process.argv.slice(2);
 var command = args[0];

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

@@ -1,7 +1,67 @@
 // @bun
-// src/lib/converter.ts
+// src/lib/config.ts
 import fs from "fs";
-var cache = new Map;
+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
+  }
+};
+function loadJsoncFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath))
+      return null;
+    const content = fs.readFileSync(filePath, "utf-8");
+    return parseJsonc(content);
+  } catch {
+    return null;
+  }
+}
+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 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 getConfigPaths(projectDir) {
+  const homeDir = os.homedir();
+  return {
+    userConfig: path.join(homeDir, ".config/opencode/systematic.json"),
+    projectConfig: path.join(projectDir, ".opencode/systematic.json"),
+    userDir: path.join(homeDir, ".config/opencode/systematic"),
+    projectDir: path.join(projectDir, ".opencode/systematic")
+  };
+}
+
+// src/lib/converter.ts
+import fs2 from "fs";
+
+// src/lib/frontmatter.ts
 function parseFrontmatter(content) {
   const lines = content.split(/\r?\n/);
   if (lines.length === 0 || lines[0].trim() !== "---") {
@@ -48,6 +108,31 @@ function formatFrontmatter(data) {
   return lines.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;
+      }
+      inFrontmatter = true;
+      continue;
+    }
+    if (frontmatterEnded || !inFrontmatter) {
+      contentLines.push(line);
+    }
+  }
+  return contentLines.join(`
+`).trim();
+}
+
+// src/lib/converter.ts
+var cache = new Map;
 function inferTemperature(name, description) {
   const sample = `${name} ${description ?? ""}`.toLowerCase();
   if (/(review|audit|security|sentinel|oracle|lint|verification|guardian)/.test(sample)) {
@@ -111,159 +196,67 @@ ${body}`;
   return content;
 }
 function convertFileWithCache(filePath, type, options = {}) {
-  const fd = fs.openSync(filePath, "r");
+  const fd = fs2.openSync(filePath, "r");
   try {
-    const stats = fs.fstatSync(fd);
+    const stats = fs2.fstatSync(fd);
     const cacheKey = `${filePath}:${type}:${options.source ?? "bundled"}:${options.agentMode ?? "subagent"}`;
     const cached = cache.get(cacheKey);
     if (cached != null && cached.mtimeMs === stats.mtimeMs) {
       return cached.converted;
     }
-    const content = fs.readFileSync(fd, "utf8");
+    const content = fs2.readFileSync(fd, "utf8");
     const converted = convertContent(content, type, options);
     cache.set(cacheKey, { mtimeMs: stats.mtimeMs, converted });
     return converted;
   } finally {
-    fs.closeSync(fd);
+    fs2.closeSync(fd);
   }
 }
 
-// src/lib/skills-core.ts
-import fs2 from "fs";
-import path from "path";
-function extractFrontmatter(filePath) {
-  try {
-    const content = fs2.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();
-        }
-      }
-    }
-    return { name, description };
-  } catch {
-    return { name: "", description: "" };
-  }
-}
-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;
-      }
-      inFrontmatter = true;
-      continue;
-    }
-    if (frontmatterEnded || !inFrontmatter) {
-      contentLines.push(line);
-    }
-  }
-  return contentLines.join(`
-`).trim();
-}
-function findSkillsInDir(dir, sourceType, maxDepth = 3) {
-  const skills = [];
-  if (!fs2.existsSync(dir))
-    return skills;
-  function recurse(currentDir, depth) {
-    if (depth > maxDepth)
-      return;
-    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        const skillFile = path.join(fullPath, "SKILL.md");
-        if (fs2.existsSync(skillFile)) {
-          const { name, description } = extractFrontmatter(skillFile);
-          skills.push({
-            path: fullPath,
-            skillFile,
-            name: name || entry.name,
-            description: description || "",
-            sourceType
-          });
-        }
-        recurse(fullPath, depth + 1);
-      }
-    }
-  }
-  recurse(dir, 0);
-  return skills;
-}
-function findAgentsInDir(dir, sourceType, maxDepth = 2) {
-  const agents = [];
-  if (!fs2.existsSync(dir))
-    return agents;
+// 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 = fs2.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        recurse(fullPath, depth + 1, entry.name);
-      } else if (entry.name.endsWith(".md")) {
-        agents.push({
-          name: entry.name.replace(/\.md$/, ""),
-          file: fullPath,
-          sourceType,
-          category
-        });
+      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);
       }
-    }
-  }
-  recurse(dir, 0);
-  return agents;
-}
-function findCommandsInDir(dir, sourceType, maxDepth = 2) {
-  const commands = [];
-  if (!fs2.existsSync(dir))
-    return commands;
-  function recurse(currentDir, depth, category) {
-    if (depth > maxDepth)
-      return;
-    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         recurse(fullPath, depth + 1, entry.name);
-      } else if (entry.name.endsWith(".md")) {
-        const baseName = entry.name.replace(/\.md$/, "");
-        const commandName = category ? `/${category}:${baseName}` : `/${baseName}`;
-        commands.push({
-          name: commandName,
-          file: fullPath,
-          sourceType,
-          category
-        });
       }
     }
   }
-  recurse(dir, 0);
-  return commands;
+  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(`
@@ -291,6 +284,23 @@ function extractAgentFrontmatter(content) {
   }
   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(`
 `);
@@ -321,4 +331,77 @@ function extractCommandFrontmatter(content) {
   return { name, description, argumentHint };
 }
 
-export { convertContent, convertFileWithCache, stripFrontmatter, findSkillsInDir, findAgentsInDir, findCommandsInDir, extractAgentFrontmatter, extractCommandFrontmatter };
+// src/lib/skills.ts
+import fs4 from "fs";
+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();
+        }
+      }
+    }
+    return { name, description };
+  } catch {
+    return { name: "", description: "" };
+  }
+}
+function findSkillsInDir(dir, maxDepth = 3) {
+  const skills = [];
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => e.isDirectory
+  });
+  for (const entry of entries) {
+    const skillFile = path3.join(entry.path, "SKILL.md");
+    if (fs4.existsSync(skillFile)) {
+      const { name, description } = extractFrontmatter(skillFile);
+      skills.push({
+        path: entry.path,
+        skillFile,
+        name: name || entry.name,
+        description: description || ""
+      });
+    }
+  }
+  return skills;
+}
+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>`;
+}
+
+export { stripFrontmatter, loadConfig, getConfigPaths, convertContent, convertFileWithCache, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter, findSkillsInDir, formatSkillsXml };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode-ai/plugin';
+export declare const SystematicPlugin: Plugin;
+export default SystematicPlugin;

package/dist/index.js

@@ -7,63 +7,65 @@ import {
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
+  formatSkillsXml,
+  loadConfig,
   stripFrontmatter
-} from "./index-hkk4125w.js";
+} from "./index-hvkf19rd.js";
 
 // src/index.ts
 import fs3 from "fs";
-import os2 from "os";
 import path3 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
-  }
-};
-function loadJsoncFile(filePath) {
-  try {
-    if (!fs.existsSync(filePath))
-      return null;
-    const content = fs.readFileSync(filePath, "utf-8");
-    return parseJsonc(content);
-  } catch {
-    return null;
-  }
-}
-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);
+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 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
+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");
     }
-  };
-  return result;
+  }
+  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/config-handler.ts
@@ -106,9 +108,9 @@ function loadSkillAsCommand(skillInfo) {
     return null;
   }
 }
-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 +121,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,9 +135,9 @@ 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;
@@ -150,9 +152,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,
@@ -171,61 +173,6 @@ function createConfigHandler(deps) {
 import fs2 from "fs";
 import path2 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" });
@@ -240,7 +187,7 @@ ${body.trim()}
 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)).sort((a, b) => a.name.localeCompare(b.name));
   };
   const buildDescription = () => {
     const skills = getSystematicSkills();
@@ -249,11 +196,12 @@ function createSkillTool(options) {
 
 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();
@@ -282,22 +230,10 @@ ${wrapped}`;
           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 {}
-      }
       const availableSystematic = skills.map((s) => `systematic:${s.name}`);
       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
@@ -319,48 +255,6 @@ var getPackageVersion = () => {
     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 +297,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,10 @@
+export type ContentType = 'skill' | 'agent' | 'command';
+export type SourceType = 'bundled' | 'external';
+export type AgentMode = 'primary' | 'subagent';
+export interface ConvertOptions {
+    source?: SourceType;
+    agentMode?: AgentMode;
+}
+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,9 @@
+interface ParsedFrontmatter {
+    data: Record<string, string | number | boolean>;
+    body: string;
+    raw: string;
+}
+export type { ParsedFrontmatter };
+export declare function parseFrontmatter(content: string): ParsedFrontmatter;
+export declare function formatFrontmatter(data: Record<string, string | number | boolean>): string;
+export declare function stripFrontmatter(content: string): string;

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[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,7 +21,7 @@
   ],
   "scripts": {
     "clean": "rimraf dist",
-    "build": "bun run clean && bun build src/index.ts src/cli.ts --outdir dist --target bun --splitting --packages external",
+    "build": "bun run clean && bun build src/index.ts src/cli.ts --outdir dist --target bun --splitting --packages external && tsc --emitDeclarationOnly",
     "dev": "bun --watch src/index.ts",
     "test": "bun test tests/unit",
     "test:integration": "bun test tests/integration",
@@ -29,7 +29,7 @@
     "typecheck": "tsc --noEmit",
     "lint": "biome check .",
     "fix": "bun run lint --fix",
-    "prepublishOnly": "bun run build && bun run test"
+    "prepublishOnly": "bun run build"
   },
   "keywords": [
     "opencode",