@fro.bot/systematic 1.6.0 → 1.7.0

package/dist/cli.js

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

package/dist/{index-95qwq9ph.js → index-yxbcy3s7.js}

@@ -502,9 +502,29 @@ function extractFrontmatter(filePath) {
     if (parseError) {
       return { name: "", description: "" };
     }
+    const metadataRaw = data.metadata;
+    let metadata;
+    if (isRecord(metadataRaw)) {
+      const entries = Object.entries(metadataRaw);
+      if (entries.every(([, v]) => typeof v === "string")) {
+        metadata = Object.fromEntries(entries);
+      }
+    }
+    const argumentHintRaw = extractNonEmptyString(data, "argument-hint");
+    const argumentHint = argumentHintRaw?.replace(/^["']|["']$/g, "") || undefined;
     return {
-      name: typeof data.name === "string" ? data.name : "",
-      description: typeof data.description === "string" ? data.description : ""
+      name: extractString(data, "name"),
+      description: extractString(data, "description"),
+      license: extractNonEmptyString(data, "license"),
+      compatibility: extractNonEmptyString(data, "compatibility"),
+      metadata,
+      disableModelInvocation: extractBoolean(data, "disable-model-invocation"),
+      userInvocable: extractBoolean(data, "user-invocable"),
+      subtask: data.context === "fork" ? true : undefined,
+      agent: extractNonEmptyString(data, "agent"),
+      model: extractNonEmptyString(data, "model"),
+      argumentHint: argumentHint !== "" ? argumentHint : undefined,
+      allowedTools: extractNonEmptyString(data, "allowed-tools")
     };
   } catch {
     return { name: "", description: "" };
@@ -519,34 +539,26 @@ function findSkillsInDir(dir, maxDepth = 3) {
   for (const entry of entries) {
     const skillFile = path3.join(entry.path, "SKILL.md");
     if (fs4.existsSync(skillFile)) {
-      const { name, description } = extractFrontmatter(skillFile);
+      const frontmatter = extractFrontmatter(skillFile);
       skills.push({
         path: entry.path,
         skillFile,
-        name: name || entry.name,
-        description: description || ""
+        name: frontmatter.name || entry.name,
+        description: frontmatter.description || "",
+        license: frontmatter.license,
+        compatibility: frontmatter.compatibility,
+        metadata: frontmatter.metadata,
+        disableModelInvocation: frontmatter.disableModelInvocation,
+        userInvocable: frontmatter.userInvocable,
+        subtask: frontmatter.subtask,
+        agent: frontmatter.agent,
+        model: frontmatter.model,
+        argumentHint: frontmatter.argumentHint,
+        allowedTools: frontmatter.allowedTools
       });
     }
   }
   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 { parseFrontmatter, loadConfig, getConfigPaths, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter, convertContent, convertFileWithCache, findSkillsInDir, formatSkillsXml };
+export { parseFrontmatter, loadConfig, getConfigPaths, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter, convertContent, convertFileWithCache, findSkillsInDir };

package/dist/index.js

@@ -6,10 +6,9 @@ import {
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
-  formatSkillsXml,
   loadConfig,
   parseFrontmatter
-} from "./index-95qwq9ph.js";
+} from "./index-yxbcy3s7.js";
 
 // src/index.ts
 import fs2 from "fs";
@@ -115,7 +114,13 @@ function loadSkill(skillInfo) {
       description: formatSkillDescription(skillInfo.description, skillInfo.name),
       path: skillInfo.path,
       skillFile: skillInfo.skillFile,
-      wrappedTemplate
+      wrappedTemplate,
+      disableModelInvocation: skillInfo.disableModelInvocation,
+      userInvocable: skillInfo.userInvocable,
+      subtask: skillInfo.subtask,
+      agent: skillInfo.agent,
+      model: skillInfo.model,
+      argumentHint: skillInfo.argumentHint
     };
   } catch {
     return null;
@@ -193,10 +198,17 @@ function loadCommandAsConfig(commandInfo) {
   }
 }
 function loadSkillAsCommand(loaded) {
-  return {
+  const config = {
     template: loaded.wrappedTemplate,
     description: loaded.description
   };
+  if (loaded.agent !== undefined)
+    config.agent = loaded.agent;
+  if (loaded.model !== undefined)
+    config.model = loaded.model;
+  if (loaded.subtask !== undefined)
+    config.subtask = loaded.subtask;
+  return config;
 }
 function collectAgents(dir, disabledAgents) {
   const agents = {};
@@ -233,6 +245,8 @@ function collectSkillsAsCommands(dir, disabledSkills) {
       continue;
     const loaded = loadSkill(skillInfo);
     if (loaded) {
+      if (loaded.userInvocable === false)
+        continue;
       commands[loaded.prefixedName] = loadSkillAsCommand(loaded);
     }
   }
@@ -262,13 +276,27 @@ function createConfigHandler(deps) {
 // src/lib/skill-tool.ts
 import path3 from "path";
 import { tool } from "@opencode-ai/plugin/tool";
+function formatSkillsXml(skills) {
+  if (skills.length === 0)
+    return "";
+  const skillLines = skills.flatMap((skill) => [
+    "  <skill>",
+    `    <name>systematic:${skill.name}</name>`,
+    `    <description>${skill.description}</description>`,
+    "  </skill>"
+  ]);
+  return ["<available_skills>", ...skillLines, "</available_skills>"].join(" ");
+}
 function createSkillTool(options) {
   const { bundledSkillsDir, disabledSkills } = options;
   const getSystematicSkills = () => {
-    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));
+    return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).map((skillInfo) => loadSkill(skillInfo)).filter((s) => s !== null).filter((s) => s.disableModelInvocation !== true).sort((a, b) => a.name.localeCompare(b.name));
   };
   const buildDescription = () => {
     const skills = getSystematicSkills();
+    if (skills.length === 0) {
+      return "Load a skill to get detailed instructions for a specific task. No skills are currently available.";
+    }
     const skillInfos = skills.map((s) => ({
       name: s.name,
       description: s.description,
@@ -276,15 +304,22 @@ function createSkillTool(options) {
       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.`;
-    return `${baseDescription}
-
-${systematicXml}`;
+    return [
+      "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.",
+      "Only the skills listed here are available:",
+      systematicXml
+    ].join(" ");
+  };
+  const buildParameterHint = () => {
+    const skills = getSystematicSkills();
+    const examples = skills.slice(0, 3).map((s) => `'systematic:${s.name}'`).join(", ");
+    const hint = examples.length > 0 ? ` (e.g., ${examples}, ...)` : "";
+    return `The skill identifier from available_skills${hint}`;
   };
   let cachedDescription = null;
+  let cachedParameterHint = null;
   return tool({
     get description() {
       if (cachedDescription == null) {
@@ -293,24 +328,45 @@ ${systematicXml}`;
       return cachedDescription;
     },
     args: {
-      name: tool.schema.string().describe("The skill identifier from available_skills (e.g., 'systematic:brainstorming')")
+      name: tool.schema.string().describe((() => {
+        if (cachedParameterHint == null) {
+          cachedParameterHint = buildParameterHint();
+        }
+        return cachedParameterHint;
+      })())
     },
-    async execute(args) {
+    async execute(args, context) {
       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) {
-        const body = extractSkillBody(matchedSkill.wrappedTemplate);
-        const dir = path3.dirname(matchedSkill.skillFile);
-        return `## Skill: ${matchedSkill.prefixedName}
-
-**Base directory**: ${dir}
-
-${body}`;
+      if (!matchedSkill) {
+        const availableSystematic = skills.map((s) => s.prefixedName);
+        throw new Error(`Skill "${requestedName}" not found. Available systematic skills: ${availableSystematic.join(", ")}`);
       }
-      const availableSystematic = skills.map((s) => s.prefixedName);
-      throw new Error(`Skill "${requestedName}" not found. Available systematic skills: ${availableSystematic.join(", ")}`);
+      const body = extractSkillBody(matchedSkill.wrappedTemplate);
+      const dir = path3.dirname(matchedSkill.skillFile);
+      await context.ask({
+        permission: "skill",
+        patterns: [matchedSkill.prefixedName],
+        always: [matchedSkill.prefixedName],
+        metadata: {}
+      });
+      context.metadata({
+        title: `Loaded skill: ${matchedSkill.prefixedName}`,
+        metadata: {
+          name: matchedSkill.prefixedName,
+          dir
+        }
+      });
+      return [
+        `## Skill: ${matchedSkill.prefixedName}`,
+        "",
+        `**Base directory**: ${dir}`,
+        "",
+        body.trim()
+      ].join(`
+`);
     }
   });
 }

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

@@ -6,6 +6,12 @@ export interface LoadedSkill {
     path: string;
     skillFile: string;
     wrappedTemplate: string;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
+    subtask?: boolean;
+    agent?: string;
+    model?: string;
+    argumentHint?: string;
 }
 export declare function formatSkillCommandName(name: string): string;
 export declare function formatSkillDescription(description: string, fallbackName: string): string;

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

@@ -1,6 +1,12 @@
 import type { ToolDefinition } from '@opencode-ai/plugin';
+import { type SkillInfo } from './skills.js';
 export interface SkillToolOptions {
     bundledSkillsDir: string;
     disabledSkills: string[];
 }
+/**
+ * Formats skills as XML for tool description.
+ * Uses indented format matching OpenCode's native skill tool.
+ */
+export declare function formatSkillsXml(skills: SkillInfo[]): string;
 export declare function createSkillTool(options: SkillToolOptions): ToolDefinition;

package/dist/lib/skills.d.ts

@@ -1,13 +1,32 @@
 export interface SkillFrontmatter {
     name: string;
     description: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
+    subtask?: boolean;
+    agent?: string;
+    model?: string;
+    argumentHint?: string;
+    allowedTools?: string;
 }
 export interface SkillInfo {
     path: string;
     skillFile: string;
     name: string;
     description: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
+    subtask?: boolean;
+    agent?: string;
+    model?: string;
+    argumentHint?: string;
+    allowedTools?: 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "main": "./dist/index.js",