@fro.bot/systematic 1.0.3 → 1.1.0

package/README.md

@@ -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
 

package/dist/index.js

@@ -8,14 +8,10 @@ import {
 } from "./index-v8dhd5s2.js";
 
 // src/index.ts
-import fs3 from "node:fs";
+import fs4 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";
@@ -68,6 +64,7 @@ function loadConfig(projectDir) {
 }
 
 // src/lib/config-handler.ts
+import fs2 from "node:fs";
 function loadAgentAsConfig(agentInfo) {
   try {
     const content = fs2.readFileSync(agentInfo.file, "utf8");
@@ -165,54 +162,193 @@ 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 fs3 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 output;
+  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 body = stripFrontmatter(content);
+  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 = fs3.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 (!fs4.existsSync(packageJsonPath))
+      return "unknown";
+    const content = fs4.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;
-    if (fs3.existsSync(customPath)) {
-      return fs3.readFileSync(customPath, "utf8");
+    const customPath = config.bootstrap.file.startsWith("~/") ? path3.join(os2.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
+    if (fs4.existsSync(customPath)) {
+      return fs4.readFileSync(customPath, "utf8");
     }
   }
-  const usingSystematicPath = path2.join(bundledSkillsDir, "using-systematic/SKILL.md");
-  if (!fs3.existsSync(usingSystematicPath))
+  const usingSystematicPath = path3.join(bundledSkillsDir, "using-systematic/SKILL.md");
+  if (!fs4.existsSync(usingSystematicPath))
     return null;
-  const fullContent = fs3.readFileSync(usingSystematicPath, "utf8");
+  const fullContent = fs4.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\` → \`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 +366,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.1.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.