@fro.bot/systematic 1.0.3 → 1.2.0

package/README.md

@@ -52,9 +52,9 @@ Quick shortcuts to invoke workflows:
 - `/deepen-plan` - Add detail to existing plans
 - `/lfg` - Let's go - start working immediately
 
-### Review Agents
+### Agents
 
-Specialized code review agents organized by category:
+Specialized agents organized by category:
 
 **Review:**
 
@@ -82,9 +82,9 @@ The plugin provides these tools to OpenCode:
 
 | Tool | Description |
 |------|-------------|
-| `systematic_find_skills` | List available skills |
-| `systematic_find_agents` | List available agents |
-| `systematic_find_commands` | List available commands |
+| `systematic_skill` | Load Systematic bundled skills |
+
+The bootstrap skill instructs OpenCode to use the native `skill` tool to load non-Systematic skills.
 
 ## Configuration
 
@@ -98,42 +98,6 @@ Create `~/.config/opencode/systematic.json` or `.opencode/systematic.json` to di
 }
 ```
 
-## Converting CEP Content
-
-The CLI includes a converter for adapting Claude Code agents, skills, and commands from Compound Engineering Plugin (CEP) to OpenCode.
-
-### Convert a Skill
-
-Skills are directories containing `SKILL.md` and supporting files:
-
-```bash
-npx @fro.bot/systematic convert skill /path/to/cep/skills/my-skill -o ./skills/my-skill
-```
-
-### Convert an Agent
-
-Agents are markdown files that get OpenCode-compatible YAML frontmatter:
-
-```bash
-npx @fro.bot/systematic convert agent /path/to/cep/agents/review/my-agent.md -o ./agents/review/my-agent.md
-```
-
-### Convert a Command
-
-Commands are markdown templates:
-
-```bash
-npx @fro.bot/systematic convert command /path/to/cep/commands/my-command.md -o ./commands/my-command.md
-```
-
-### Dry Run
-
-Preview conversion without writing files:
-
-```bash
-npx @fro.bot/systematic convert skill /path/to/skill --dry-run
-```
-
 ## Development
 
 ```bash

package/dist/cli.js

@@ -1,191 +1,14 @@
 #!/usr/bin/env node
 import {
+  convertContent,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir
-} from "./index-v8dhd5s2.js";
+} from "./index-33zyxync.js";
 
 // src/cli.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
-
-// src/lib/converter.ts
 import fs from "node:fs";
 import path from "node:path";
-function parseFrontmatter(raw) {
-  const lines = raw.split(/\r?\n/);
-  if (lines.length === 0 || lines[0].trim() !== "---") {
-    return { data: {}, body: 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: raw };
-  }
-  const yamlLines = lines.slice(1, endIndex);
-  const body = lines.slice(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;
-    }
-  }
-  return { data, body };
-}
-function formatFrontmatter(data, body) {
-  const lines = [];
-  if (data.description)
-    lines.push(`description: ${data.description}`);
-  if (data.mode)
-    lines.push(`mode: ${data.mode}`);
-  if (data.model)
-    lines.push(`model: ${data.model}`);
-  if (data.temperature !== undefined)
-    lines.push(`temperature: ${data.temperature}`);
-  if (lines.length === 0)
-    return body;
-  return ["---", ...lines, "---", "", body].join(`
-`);
-}
-function inferTemperature(name, description) {
-  const sample = `${name} ${description || ""}`.toLowerCase();
-  if (/(review|audit|security|sentinel|oracle|lint|verification|guardian)/.test(sample)) {
-    return 0.1;
-  }
-  if (/(plan|planning|architecture|strategist|analysis|research)/.test(sample)) {
-    return 0.2;
-  }
-  if (/(doc|readme|changelog|editor|writer)/.test(sample)) {
-    return 0.3;
-  }
-  if (/(brainstorm|creative|ideate|design|concept)/.test(sample)) {
-    return 0.6;
-  }
-  return 0.3;
-}
-function normalizeModel(model) {
-  if (model.includes("/"))
-    return model;
-  if (/^claude-/.test(model))
-    return `anthropic/${model}`;
-  if (/^(gpt-|o1-|o3-)/.test(model))
-    return `openai/${model}`;
-  if (/^gemini-/.test(model))
-    return `google/${model}`;
-  return `anthropic/${model}`;
-}
-function convertAgent(sourcePath, options = {}) {
-  const content = fs.readFileSync(sourcePath, "utf-8");
-  const name = path.basename(sourcePath, ".md");
-  const { data, body } = parseFrontmatter(content);
-  const existingDescription = data.description;
-  const existingModel = data.model;
-  let description = existingDescription;
-  if (!description) {
-    const firstLine = body.split(`
-`).find((l) => l.trim() && !l.startsWith("#"));
-    description = firstLine?.slice(0, 100) || `${name} agent`;
-  }
-  const frontmatter = {
-    description,
-    mode: "subagent",
-    temperature: inferTemperature(name, description)
-  };
-  if (existingModel && existingModel !== "inherit") {
-    frontmatter.model = normalizeModel(existingModel);
-  }
-  const converted = formatFrontmatter(frontmatter, body.trim());
-  const outputPath = options.output || sourcePath;
-  if (!options.dryRun) {
-    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-    fs.writeFileSync(outputPath, converted);
-  }
-  return {
-    type: "agent",
-    sourcePath,
-    outputPath,
-    converted: true,
-    files: [path.basename(outputPath)]
-  };
-}
-function convertCommand(sourcePath, options = {}) {
-  const content = fs.readFileSync(sourcePath, "utf-8");
-  const outputPath = options.output || sourcePath;
-  if (!options.dryRun) {
-    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-    fs.writeFileSync(outputPath, content);
-  }
-  return {
-    type: "command",
-    sourcePath,
-    outputPath,
-    converted: true,
-    files: [path.basename(outputPath)]
-  };
-}
-function convertSkill(sourcePath, options = {}) {
-  const stats = fs.statSync(sourcePath);
-  if (!stats.isDirectory()) {
-    throw new Error(`Skill source must be a directory: ${sourcePath}`);
-  }
-  const skillName = path.basename(sourcePath);
-  const outputPath = options.output || sourcePath;
-  const files = [];
-  function copyDir(src, dest) {
-    if (!options.dryRun) {
-      fs.mkdirSync(dest, { recursive: true });
-    }
-    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-      if (entry.isDirectory()) {
-        copyDir(srcPath, destPath);
-      } else {
-        files.push(path.relative(outputPath, destPath));
-        if (!options.dryRun) {
-          fs.copyFileSync(srcPath, destPath);
-        }
-      }
-    }
-  }
-  copyDir(sourcePath, outputPath);
-  return {
-    type: "skill",
-    sourcePath,
-    outputPath,
-    converted: true,
-    files
-  };
-}
-function convert(type, sourcePath, options = {}) {
-  switch (type) {
-    case "agent":
-      return convertAgent(sourcePath, options);
-    case "command":
-      return convertCommand(sourcePath, options);
-    case "skill":
-      return convertSkill(sourcePath, options);
-    default:
-      throw new Error(`Unknown type: ${type}`);
-  }
-}
-
-// src/cli.ts
 var VERSION = "0.1.0";
 var HELP = `
 systematic - OpenCode plugin for systematic engineering workflows
@@ -195,32 +18,32 @@ Usage:
 
 Commands:
   list [type]          List available skills, agents, or commands
-  convert <type> <source> [--output <path>] [--dry-run]
-                       Convert Claude Code content to OpenCode format
-    Types: skill, agent, command
+  convert <type> <file> [--mode=primary|subagent]
+                       Convert and inspect a file (outputs to stdout)
   config [subcommand]  Configuration management
     show               Show configuration
     path               Print config file locations
 
 Options:
-  --output, -o         Output path for convert command
-  --dry-run            Preview conversion without writing files
   -h, --help           Show this help message
   -v, --version        Show version
 
 Examples:
   systematic list skills
-  systematic convert skill /path/to/cep/skills/agent-browser -o ./skills/agent-browser
-  systematic convert agent /path/to/agent.md --dry-run
+  systematic list agents
+  systematic convert agent ./agents/my-agent.md
+  systematic convert agent ./agents/my-agent.md --mode=primary
+  systematic convert skill ./skills/my-skill/SKILL.md
+  systematic config show
 `;
 function getUserConfigDir() {
-  return path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".config/opencode");
+  return path.join(process.env.HOME || process.env.USERPROFILE || ".", ".config/opencode");
 }
 function getProjectConfigDir() {
-  return path2.join(process.cwd(), ".opencode");
+  return path.join(process.cwd(), ".opencode");
 }
 function listItems(type) {
-  const packageRoot = path2.resolve(import.meta.dirname, "..");
+  const packageRoot = path.resolve(import.meta.dirname, "..");
   const bundledDir = packageRoot;
   let finder;
   let subdir;
@@ -241,7 +64,7 @@ function listItems(type) {
       console.error(`Unknown type: ${type}. Use: skills, agents, commands`);
       process.exit(1);
   }
-  const items = finder(path2.join(bundledDir, subdir), "bundled");
+  const items = finder(path.join(bundledDir, subdir), "bundled");
   if (items.length === 0) {
     console.log(`No ${type} found.`);
     return;
@@ -252,71 +75,57 @@ function listItems(type) {
     console.log(`  ${item.name} (${item.sourceType})`);
   }
 }
+function runConvert(type, filePath, modeArg) {
+  const validTypes = ["skill", "agent", "command"];
+  if (!validTypes.includes(type)) {
+    console.error(`Invalid type: ${type}. Must be one of: ${validTypes.join(", ")}`);
+    process.exit(1);
+  }
+  const resolvedPath = path.resolve(filePath);
+  if (!fs.existsSync(resolvedPath)) {
+    console.error(`File not found: ${resolvedPath}`);
+    process.exit(1);
+  }
+  let agentMode = "subagent";
+  if (modeArg) {
+    const modeMatch = modeArg.match(/^--mode=(primary|subagent)$/);
+    if (modeMatch) {
+      agentMode = modeMatch[1];
+    } else {
+      console.error("Invalid --mode flag. Use: --mode=primary or --mode=subagent");
+      process.exit(1);
+    }
+  }
+  const content = fs.readFileSync(resolvedPath, "utf8");
+  const converted = convertContent(content, type, { agentMode });
+  console.log(converted);
+}
 function configShow() {
   const userDir = getUserConfigDir();
   const projectDir = getProjectConfigDir();
   console.log(`Configuration locations:
 `);
-  console.log(`  User config:    ${path2.join(userDir, "systematic.json")}`);
-  console.log(`  Project config: ${path2.join(projectDir, "systematic.json")}`);
-  const projectConfig = path2.join(projectDir, "systematic.json");
-  if (fs2.existsSync(projectConfig)) {
+  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(`
 Project configuration:`);
-    console.log(fs2.readFileSync(projectConfig, "utf-8"));
+    console.log(fs.readFileSync(projectConfig, "utf-8"));
   }
-  const userConfig = path2.join(userDir, "systematic.json");
-  if (fs2.existsSync(userConfig)) {
+  const userConfig = path.join(userDir, "systematic.json");
+  if (fs.existsSync(userConfig)) {
     console.log(`
 User configuration:`);
-    console.log(fs2.readFileSync(userConfig, "utf-8"));
+    console.log(fs.readFileSync(userConfig, "utf-8"));
   }
 }
 function configPath() {
   const userDir = getUserConfigDir();
   const projectDir = getProjectConfigDir();
   console.log("Config file paths:");
-  console.log(`  User:    ${path2.join(userDir, "systematic.json")}`);
-  console.log(`  Project: ${path2.join(projectDir, "systematic.json")}`);
-}
-function runConvert(args) {
-  const typeArg = args[1];
-  const sourceArg = args[2];
-  if (!typeArg || !sourceArg) {
-    console.error("Usage: systematic convert <type> <source> [--output <path>] [--dry-run]");
-    console.error("Types: skill, agent, command");
-    process.exit(1);
-  }
-  const validTypes = ["skill", "agent", "command"];
-  if (!validTypes.includes(typeArg)) {
-    console.error(`Invalid type: ${typeArg}. Must be one of: ${validTypes.join(", ")}`);
-    process.exit(1);
-  }
-  const sourcePath = path2.resolve(sourceArg);
-  if (!fs2.existsSync(sourcePath)) {
-    console.error(`Source not found: ${sourcePath}`);
-    process.exit(1);
-  }
-  const outputIndex = args.findIndex((a) => a === "--output" || a === "-o");
-  const outputPath = outputIndex !== -1 ? path2.resolve(args[outputIndex + 1]) : undefined;
-  const dryRun = args.includes("--dry-run");
-  try {
-    const result = convert(typeArg, sourcePath, { output: outputPath, dryRun });
-    if (dryRun) {
-      console.log(`[DRY RUN] Would convert ${result.type}:`);
-    } else {
-      console.log(`Converted ${result.type}:`);
-    }
-    console.log(`  Source: ${result.sourcePath}`);
-    console.log(`  Output: ${result.outputPath}`);
-    console.log("  Files:");
-    for (const file of result.files) {
-      console.log(`    - ${file}`);
-    }
-  } catch (err) {
-    console.error(`Conversion failed: ${err.message}`);
-    process.exit(1);
-  }
+  console.log(`  User:    ${path.join(userDir, "systematic.json")}`);
+  console.log(`  Project: ${path.join(projectDir, "systematic.json")}`);
 }
 var args = process.argv.slice(2);
 var command = args[0];
@@ -325,7 +134,12 @@ switch (command) {
     listItems(args[1] || "skills");
     break;
   case "convert":
-    runConvert(args);
+    if (!args[1] || !args[2]) {
+      console.error("Usage: systematic convert <type> <file> [--mode=primary|subagent]");
+      console.error("  type: skill, agent, or command");
+      process.exit(1);
+    }
+    runConvert(args[1], args[2], args[3]);
     break;
   case "config":
     switch (args[1]) {

package/dist/{index-v8dhd5s2.js → index-33zyxync.js}

@@ -1,9 +1,138 @@
-// src/lib/skills-core.ts
+// src/lib/converter.ts
 import fs from "node:fs";
+var cache = new Map;
+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 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;
+    }
+  }
+  return { data, body, raw };
+}
+function formatFrontmatter(data) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(data)) {
+    lines.push(`${key}: ${value}`);
+  }
+  lines.push("---");
+  return lines.join(`
+`);
+}
+function inferTemperature(name, description) {
+  const sample = `${name} ${description ?? ""}`.toLowerCase();
+  if (/(review|audit|security|sentinel|oracle|lint|verification|guardian)/.test(sample)) {
+    return 0.1;
+  }
+  if (/(plan|planning|architecture|strategist|analysis|research)/.test(sample)) {
+    return 0.2;
+  }
+  if (/(doc|readme|changelog|editor|writer)/.test(sample)) {
+    return 0.3;
+  }
+  if (/(brainstorm|creative|ideate|design|concept)/.test(sample)) {
+    return 0.6;
+  }
+  return 0.3;
+}
+function normalizeModel(model) {
+  if (model.includes("/"))
+    return model;
+  if (model === "inherit")
+    return model;
+  if (/^claude-/.test(model))
+    return `anthropic/${model}`;
+  if (/^(gpt-|o1-|o3-)/.test(model))
+    return `openai/${model}`;
+  if (/^gemini-/.test(model))
+    return `google/${model}`;
+  return `anthropic/${model}`;
+}
+function transformAgentFrontmatter(data, agentMode) {
+  const name = typeof data.name === "string" ? data.name : "";
+  const description = typeof data.description === "string" ? data.description : "";
+  const newData = {
+    description: description || `${name} agent`,
+    mode: agentMode
+  };
+  if (typeof data.model === "string" && data.model !== "inherit") {
+    newData.model = normalizeModel(data.model);
+  }
+  if (typeof data.temperature === "number") {
+    newData.temperature = data.temperature;
+  } else {
+    newData.temperature = inferTemperature(name, description);
+  }
+  return newData;
+}
+function convertContent(content, type, options = {}) {
+  if (content === "")
+    return "";
+  const { data, body, raw } = parseFrontmatter(content);
+  const hasFrontmatter = raw !== "";
+  if (!hasFrontmatter) {
+    return content;
+  }
+  if (type === "agent") {
+    const agentMode = options.agentMode ?? "subagent";
+    const transformedData = transformAgentFrontmatter(data, agentMode);
+    return `${formatFrontmatter(transformedData)}
+${body}`;
+  }
+  return content;
+}
+function convertFileWithCache(filePath, type, options = {}) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const stats = fs.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 converted = convertContent(content, type, options);
+    cache.set(cacheKey, { mtimeMs: stats.mtimeMs, converted });
+    return converted;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+// src/lib/skills-core.ts
+import fs2 from "node:fs";
 import path from "node:path";
 function extractFrontmatter(filePath) {
   try {
-    const content = fs.readFileSync(filePath, "utf8");
+    const content = fs2.readFileSync(filePath, "utf8");
     const lines = content.split(`
 `);
     let inFrontmatter = false;
@@ -56,17 +185,17 @@ function stripFrontmatter(content) {
 }
 function findSkillsInDir(dir, sourceType, maxDepth = 3) {
   const skills = [];
-  if (!fs.existsSync(dir))
+  if (!fs2.existsSync(dir))
     return skills;
   function recurse(currentDir, depth) {
     if (depth > maxDepth)
       return;
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    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 (fs.existsSync(skillFile)) {
+        if (fs2.existsSync(skillFile)) {
           const { name, description } = extractFrontmatter(skillFile);
           skills.push({
             path: fullPath,
@@ -85,12 +214,12 @@ function findSkillsInDir(dir, sourceType, maxDepth = 3) {
 }
 function findAgentsInDir(dir, sourceType, maxDepth = 2) {
   const agents = [];
-  if (!fs.existsSync(dir))
+  if (!fs2.existsSync(dir))
     return agents;
   function recurse(currentDir, depth, category) {
     if (depth > maxDepth)
       return;
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(currentDir, entry.name);
       if (entry.isDirectory()) {
@@ -110,12 +239,12 @@ function findAgentsInDir(dir, sourceType, maxDepth = 2) {
 }
 function findCommandsInDir(dir, sourceType, maxDepth = 2) {
   const commands = [];
-  if (!fs.existsSync(dir))
+  if (!fs2.existsSync(dir))
     return commands;
   function recurse(currentDir, depth, category) {
     if (depth > maxDepth)
       return;
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(currentDir, entry.name);
       if (entry.isDirectory()) {
@@ -191,4 +320,4 @@ function extractCommandFrontmatter(content) {
   return { name, description, argumentHint };
 }
 
-export { stripFrontmatter, findSkillsInDir, findAgentsInDir, findCommandsInDir, extractAgentFrontmatter, extractCommandFrontmatter };
+export { convertContent, convertFileWithCache, stripFrontmatter, findSkillsInDir, findAgentsInDir, findCommandsInDir, extractAgentFrontmatter, extractCommandFrontmatter };

package/dist/index.js

@@ -1,21 +1,19 @@
 import {
+  convertContent,
+  convertFileWithCache,
   extractAgentFrontmatter,
   extractCommandFrontmatter,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
   stripFrontmatter
-} from "./index-v8dhd5s2.js";
+} from "./index-33zyxync.js";
 
 // src/index.ts
 import fs3 from "node:fs";
 import os2 from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 import { fileURLToPath } from "node:url";
-import { tool } from "@opencode-ai/plugin/tool";
-
-// src/lib/config-handler.ts
-import fs2 from "node:fs";
 
 // src/lib/config.ts
 import fs from "node:fs";
@@ -70,11 +68,14 @@ function loadConfig(projectDir) {
 // src/lib/config-handler.ts
 function loadAgentAsConfig(agentInfo) {
   try {
-    const content = fs2.readFileSync(agentInfo.file, "utf8");
-    const { name, description, prompt } = extractAgentFrontmatter(content);
+    const converted = convertFileWithCache(agentInfo.file, "agent", {
+      source: "bundled",
+      agentMode: "subagent"
+    });
+    const { description, prompt } = extractAgentFrontmatter(converted);
     return {
-      description: description || `${name || agentInfo.name} agent`,
-      prompt: prompt || stripFrontmatter(content)
+      description: description || `${agentInfo.name} agent`,
+      prompt: prompt || stripFrontmatter(converted)
     };
   } catch {
     return null;
@@ -82,11 +83,11 @@ function loadAgentAsConfig(agentInfo) {
 }
 function loadCommandAsConfig(commandInfo) {
   try {
-    const content = fs2.readFileSync(commandInfo.file, "utf8");
-    const { name, description } = extractCommandFrontmatter(content);
+    const converted = convertFileWithCache(commandInfo.file, "command", { source: "bundled" });
+    const { name, description } = extractCommandFrontmatter(converted);
     const cleanName = commandInfo.name.replace(/^\//, "");
     return {
-      template: stripFrontmatter(content),
+      template: stripFrontmatter(converted),
       description: description || `${name || cleanName} command`
     };
   } catch {
@@ -95,9 +96,9 @@ function loadCommandAsConfig(commandInfo) {
 }
 function loadSkillAsCommand(skillInfo) {
   try {
-    const content = fs2.readFileSync(skillInfo.skillFile, "utf8");
+    const converted = convertFileWithCache(skillInfo.skillFile, "skill", { source: "bundled" });
     return {
-      template: stripFrontmatter(content),
+      template: stripFrontmatter(converted),
       description: skillInfo.description || `${skillInfo.name} skill`
     };
   } catch {
@@ -165,32 +166,168 @@ function createConfigHandler(deps) {
   };
 }
 
-// src/index.ts
-var __dirname2 = path2.dirname(fileURLToPath(import.meta.url));
-var packageRoot = path2.resolve(__dirname2, "..");
-var bundledSkillsDir = path2.join(packageRoot, "skills");
-var bundledAgentsDir = path2.join(packageRoot, "agents");
-var bundledCommandsDir = path2.join(packageRoot, "commands");
-function formatItemList(items, emptyMessage, header) {
-  if (items.length === 0)
-    return emptyMessage;
-  let output = header;
-  for (const item of items) {
-    output += `- ${item.name} (${item.sourceType})
-`;
+// src/lib/skill-tool.ts
+import fs2 from "node:fs";
+import path2 from "node: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 output;
+  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));
+  };
+  const buildDescription = () => {
+    const skills = getSystematicSkills();
+    const systematicXml = formatSkillsXml(skills);
+    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);
+  };
+  let cachedDescription = null;
+  const toolDef = tool({
+    get description() {
+      if (cachedDescription == null) {
+        cachedDescription = buildDescription();
+      }
+      return cachedDescription;
+    },
+    args: {
+      name: tool.schema.string().describe("The skill identifier from available_skills (e.g., 'systematic:brainstorming')")
+    },
+    async execute(args) {
+      const requestedName = args.name;
+      const normalizedName = requestedName.startsWith("systematic:") ? requestedName.slice("systematic:".length) : requestedName;
+      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}
+
+**Base directory**: ${matchedSkill.path}
+
+${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 {}
+      }
+      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
+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 hasLoggedInit = false;
+var getPackageVersion = () => {
+  try {
+    if (!fs3.existsSync(packageJsonPath))
+      return "unknown";
+    const content = fs3.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("~/") ? path2.join(os2.homedir(), config.bootstrap.file.slice(2)) : 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 = path2.join(bundledSkillsDir, "using-systematic/SKILL.md");
+  const usingSystematicPath = path3.join(bundledSkillsDir, "using-systematic/SKILL.md");
   if (!fs3.existsSync(usingSystematicPath))
     return null;
   const fullContent = fs3.readFileSync(usingSystematicPath, "utf8");
@@ -200,19 +337,23 @@ When skills reference tools you don't have, substitute OpenCode equivalents:
 - \`TodoWrite\` → \`update_plan\`
 - \`Task\` tool with subagents → Use OpenCode's subagent system (@mention)
 - \`Skill\` tool → OpenCode's native \`skill\` tool
+- \`SystematicSkill\` tool → \`systematic_skill\` (Systematic plugin skills)
 - \`Read\`, \`Write\`, \`Edit\`, \`Bash\` → 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}/\`
-Use \`systematic_find_skills\` to list all available skills.`;
+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 skill tool to load "using-systematic" again - that would be redundant.**
+**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}
 
@@ -230,56 +371,37 @@ var SystematicPlugin = async ({ client, directory }) => {
   return {
     config: configHandler,
     tool: {
-      systematic_find_skills: tool({
-        description: "List all available skills in the bundled skill library.",
-        args: {},
-        execute: async () => {
-          const bundledSkills = findSkillsInDir(bundledSkillsDir, "bundled", 3);
-          const skills = bundledSkills.filter((s) => !config.disabled_skills.includes(s.name)).sort((a, b) => a.name.localeCompare(b.name));
-          if (skills.length === 0) {
-            return "No skills available. Skills are bundled with the systematic plugin.";
-          }
-          let output = `Available skills:
-
-`;
-          for (const skill of skills) {
-            output += `systematic:${skill.name}
-`;
-            if (skill.description) {
-              output += `  ${skill.description}
-`;
-            }
-            output += `  Directory: ${skill.path}
-
-`;
-          }
-          return output.trim();
-        }
-      }),
-      systematic_find_agents: tool({
-        description: "List all available review agents.",
-        args: {},
-        execute: async () => {
-          const bundledAgents = findAgentsInDir(bundledAgentsDir, "bundled");
-          const agents = bundledAgents.filter((a) => !config.disabled_agents.includes(a.name)).sort((a, b) => a.name.localeCompare(b.name));
-          return formatItemList(agents, "No agents available.", `Available agents:
-
-`);
-        }
-      }),
-      systematic_find_commands: tool({
-        description: "List all available commands.",
-        args: {},
-        execute: async () => {
-          const bundledCommands = findCommandsInDir(bundledCommandsDir, "bundled");
-          const commands = bundledCommands.filter((c) => !config.disabled_commands.includes(c.name.replace(/^\//, ""))).sort((a, b) => a.name.localeCompare(b.name));
-          return formatItemList(commands, "No commands available.", `Available commands:
-
-`);
-        }
+      systematic_skill: createSkillTool({
+        bundledSkillsDir,
+        disabledSkills: config.disabled_skills
       })
     },
     "experimental.chat.system.transform": async (_input, output) => {
+      if (!hasLoggedInit) {
+        hasLoggedInit = true;
+        const packageVersion = getPackageVersion();
+        try {
+          await client.app.log({
+            body: {
+              service: "systematic",
+              level: "info",
+              message: "Systematic plugin initialized",
+              extra: {
+                version: packageVersion,
+                bootstrapEnabled: config.bootstrap.enabled,
+                disabledSkillsCount: config.disabled_skills.length,
+                disabledAgentsCount: config.disabled_agents.length,
+                disabledCommandsCount: config.disabled_commands.length
+              }
+            }
+          });
+        } catch {}
+      }
+      const existingSystem = output.system.join(`
+`).toLowerCase();
+      if (existingSystem.includes("title generator") || existingSystem.includes("generate a title")) {
+        return;
+      }
       const content = getBootstrapContent(config);
       if (content) {
         if (!output.system) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "main": "./dist/index.js",
@@ -50,7 +50,7 @@
     "@opencode-ai/plugin": "^1.1.30"
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.9.0",
+    "@biomejs/biome": "^2.0.0",
     "@opencode-ai/plugin": "^1.1.30",
     "@types/bun": "latest",
     "@types/node": "^22.0.0",

package/skills/using-systematic/SKILL.md

@@ -13,7 +13,7 @@ This is not negotiable. This is not optional. You cannot rationalize your way ou
 
 ## How to Access Skills
 
-Use the `skill` tool. When you invoke a skill, its content is loaded and presented to you—follow it directly.
+Use the `systematic_skill` tool for Systematic bundled skills. Use the native `skill` tool for non-Systematic skills. When you invoke a skill, its content is loaded and presented to you—follow it directly.
 
 # Using Skills
 
@@ -25,7 +25,7 @@ Use the `skill` tool. When you invoke a skill, its content is loaded and present
 digraph skill_flow {
     "User message received" [shape=doublecircle];
     "Might any skill apply?" [shape=diamond];
-    "Invoke `skill` tool" [shape=box];
+    "Invoke `systematic_skill` tool" [shape=box];
     "Announce: 'Using [skill] to [purpose]'" [shape=box];
     "Has checklist?" [shape=diamond];
     "Create todo per item" [shape=box];
@@ -33,9 +33,9 @@ digraph skill_flow {
     "Respond (including clarifications)" [shape=doublecircle];
 
     "User message received" -> "Might any skill apply?";
-    "Might any skill apply?" -> "Invoke `skill` tool" [label="yes, even 1%"];
+    "Might any skill apply?" -> "Invoke `systematic_skill` tool" [label="yes, even 1%"];
     "Might any skill apply?" -> "Respond (including clarifications)" [label="definitely not"];
-    "Invoke `skill` tool" -> "Announce: 'Using [skill] to [purpose]'";
+    "Invoke `systematic_skill` tool" -> "Announce: 'Using [skill] to [purpose]'";
     "Announce: 'Using [skill] to [purpose]'" -> "Has checklist?";
     "Has checklist?" -> "Create todo per item" [label="yes"];
     "Has checklist?" -> "Follow skill exactly" [label="no"];
@@ -91,4 +91,4 @@ Skills are resolved in priority order:
 2. **User skills**: `~/.config/opencode/skills/`
 3. **Bundled skills**: Provided by systematic plugin
 
-Use `systematic_find_skills` to see all available skills and their sources.
+Systematic bundled skills are listed in the `systematic_skill` tool description. Use the native `skill` tool for skills outside the Systematic plugin.