@fro.bot/systematic 2.32.2 → 2.33.1

package/dist/cli.js

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

package/dist/{index-wjkgb2gb.js → index-vyzhzvap.js}

@@ -485,53 +485,65 @@ function walkDir(rootDir, options = {}) {
 }
 
 // src/lib/skills.ts
+function parseMetadata(data) {
+  const metadataRaw = data.metadata;
+  if (!isRecord(metadataRaw)) {
+    return;
+  }
+  const entries = Object.entries(metadataRaw);
+  if (!entries.every(([, v]) => typeof v === "string")) {
+    return;
+  }
+  return Object.fromEntries(entries);
+}
+function parseDeprecated(data) {
+  const deprecatedRaw = data.deprecated;
+  if (!isRecord(deprecatedRaw)) {
+    return;
+  }
+  const since = typeof deprecatedRaw.since === "string" && deprecatedRaw.since !== "" ? deprecatedRaw.since : undefined;
+  const removal = typeof deprecatedRaw.removal === "string" && deprecatedRaw.removal !== "" ? deprecatedRaw.removal : undefined;
+  if (since === undefined || removal === undefined) {
+    return;
+  }
+  const deprecated = { since, removal };
+  if (typeof deprecatedRaw.replacement === "string") {
+    deprecated.replacement = deprecatedRaw.replacement;
+  }
+  if (typeof deprecatedRaw.reason === "string") {
+    deprecated.reason = deprecatedRaw.reason;
+  }
+  return deprecated;
+}
+function extractFrontmatterFromContent(content) {
+  const { data, parseError } = parseFrontmatter(content);
+  if (parseError) {
+    return { name: "", description: "" };
+  }
+  const metadata = parseMetadata(data);
+  const deprecated = parseDeprecated(data);
+  const argumentHintRaw = extractNonEmptyString(data, "argument-hint");
+  const argumentHint = argumentHintRaw?.replace(/^["']|["']$/g, "") || undefined;
+  return {
+    name: extractString(data, "name"),
+    description: extractString(data, "description"),
+    license: extractNonEmptyString(data, "license"),
+    compatibility: extractNonEmptyString(data, "compatibility"),
+    metadata,
+    deprecated,
+    disableModelInvocation: extractBoolean(data, "disable-model-invocation"),
+    userInvocable: extractBoolean(data, "user-invocable"),
+    subtask: data.context === "fork" ? true : extractBoolean(data, "subtask") ?? undefined,
+    agent: extractNonEmptyString(data, "agent"),
+    model: extractNonEmptyString(data, "model"),
+    argumentHint: argumentHint !== "" ? argumentHint : undefined,
+    allowedTools: extractNonEmptyString(data, "allowed-tools")
+  };
+}
 function extractFrontmatter(filePath) {
   try {
     const content = fs3.readFileSync(filePath, "utf8");
-    const { data, parseError } = parseFrontmatter(content);
-    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 deprecatedRaw = data.deprecated;
-    let deprecated;
-    if (isRecord(deprecatedRaw)) {
-      const since = typeof deprecatedRaw.since === "string" && deprecatedRaw.since !== "" ? deprecatedRaw.since : undefined;
-      const removal = typeof deprecatedRaw.removal === "string" && deprecatedRaw.removal !== "" ? deprecatedRaw.removal : undefined;
-      if (since !== undefined && removal !== undefined) {
-        deprecated = { since, removal };
-        if (typeof deprecatedRaw.replacement === "string") {
-          deprecated.replacement = deprecatedRaw.replacement;
-        }
-        if (typeof deprecatedRaw.reason === "string") {
-          deprecated.reason = deprecatedRaw.reason;
-        }
-      }
-    }
-    const argumentHintRaw = extractNonEmptyString(data, "argument-hint");
-    const argumentHint = argumentHintRaw?.replace(/^["']|["']$/g, "") || undefined;
-    return {
-      name: extractString(data, "name"),
-      description: extractString(data, "description"),
-      license: extractNonEmptyString(data, "license"),
-      compatibility: extractNonEmptyString(data, "compatibility"),
-      metadata,
-      deprecated,
-      disableModelInvocation: extractBoolean(data, "disable-model-invocation"),
-      userInvocable: extractBoolean(data, "user-invocable"),
-      subtask: data.context === "fork" ? true : extractBoolean(data, "subtask") ?? undefined,
-      agent: extractNonEmptyString(data, "agent"),
-      model: extractNonEmptyString(data, "model"),
-      argumentHint: argumentHint !== "" ? argumentHint : undefined,
-      allowedTools: extractNonEmptyString(data, "allowed-tools")
-    };
+    return extractFrontmatterFromContent(content);
   } catch {
     return { name: "", description: "" };
   }
@@ -16040,6 +16052,10 @@ function createSystematicConfigSchema(opts) {
         { enabled: true },
         { enabled: false, file: ".opencode/custom-prompt.md" }
       ]
+    }),
+    skills_as_commands: exports_external.boolean().default(true).meta({
+      description: "Register skills discovered from user/project skill directories (OpenCode config and other agent-harness-standard locations) as slash commands. Default true.",
+      examples: [true, false]
     })
   }).strict().meta({
     description: "Systematic user configuration file (systematic.json / systematic.jsonc)",
@@ -16071,7 +16087,8 @@ var DEFAULT_CONFIG = {
     enabled: true
   },
   agents: {},
-  categories: {}
+  categories: {},
+  skills_as_commands: true
 };
 var SECURITY_OVERLAY_FIELDS2 = new Set(SECURITY_OVERLAY_FIELDS);
 var CURRENT_SKILL_NAMES_SET = new Set(BUNDLED_SKILL_NAMES);
@@ -16240,7 +16257,8 @@ function loadConfigWithSources(projectDir) {
       ...customConfig?.bootstrap
     },
     agents: overlayValues(overlays.agents),
-    categories: overlayValues(overlays.categories)
+    categories: overlayValues(overlays.categories),
+    skills_as_commands: customConfig?.skills_as_commands ?? projectConfig?.skills_as_commands ?? userConfig?.skills_as_commands ?? DEFAULT_CONFIG.skills_as_commands
   };
   const warned = new Set;
   const droppedSkills = computeDroppedNames(result.disabled_skills, CURRENT_SKILL_NAMES_SET);
@@ -16407,4 +16425,4 @@ function extractCommandFrontmatter(content) {
   };
 }
 
-export { parseFrontmatter, isRecord, convertContent, convertFileWithCache, findSkillsInDir, exports_external, AgentOverlaySchema, CategoryOverlaySchema, loadConfig, loadConfigWithSources, getConfigPaths, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter };
+export { parseFrontmatter, isRecord, convertContent, convertFileWithCache, walkDir, extractFrontmatterFromContent, findSkillsInDir, exports_external, AgentOverlaySchema, CategoryOverlaySchema, loadConfig, loadConfigWithSources, getConfigPaths, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter };

package/dist/index.js

@@ -6,18 +6,20 @@ import {
   exports_external,
   extractAgentFrontmatter,
   extractCommandFrontmatter,
+  extractFrontmatterFromContent,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
   isRecord,
   loadConfig,
   loadConfigWithSources,
-  parseFrontmatter
-} from "./index-wjkgb2gb.js";
+  parseFrontmatter,
+  walkDir
+} from "./index-vyzhzvap.js";
 
 // src/index.ts
-import fs5 from "fs";
-import path7 from "path";
+import fs6 from "fs";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/lib/bootstrap.ts
@@ -237,6 +239,10 @@ ${skillUsage}${catalogSection}
 </SYSTEMATIC_WORKFLOWS>`;
 }
 
+// src/lib/config-handler.ts
+import os3 from "os";
+import path7 from "path";
+
 // src/lib/agent-overlays.ts
 import fs2 from "fs";
 import path4 from "path";
@@ -624,11 +630,136 @@ function throwConfigError(sourcePath, keyPath, message) {
   throw new Error(`Invalid Systematic config in ${sourcePath}: ${keyPath} ${message}`);
 }
 
+// src/lib/discovered-skills.ts
+import fs3 from "fs";
+import path5 from "path";
+var SKILL_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function isValidSkillName(name) {
+  return name.length >= 1 && name.length <= 64 && SKILL_NAME_REGEX.test(name);
+}
+function findGitWorktreeRoot(startDir) {
+  let current = path5.resolve(startDir);
+  while (true) {
+    try {
+      if (fs3.existsSync(path5.join(current, ".git"))) {
+        return current;
+      }
+    } catch {
+      return null;
+    }
+    const parent = path5.dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function upWalk(targets, start, stop) {
+  const results = [];
+  let current = path5.resolve(start);
+  const resolvedStop = stop === undefined ? undefined : path5.resolve(stop);
+  while (true) {
+    for (const target of targets) {
+      const candidate = path5.join(current, target);
+      try {
+        if (fs3.existsSync(candidate)) {
+          results.push(candidate);
+        }
+      } catch {}
+    }
+    if (resolvedStop !== undefined && current === resolvedStop)
+      break;
+    const parent = path5.dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return results;
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values));
+}
+function buildOpencodeConfigDirs(startDir, homeDir, gitRoot, globalConfigDir, opencodeConfigDirOverride) {
+  const dirs = [globalConfigDir];
+  dirs.push(...upWalk([".opencode"], startDir, gitRoot ?? startDir));
+  dirs.push(...upWalk([".opencode"], homeDir, homeDir));
+  if (opencodeConfigDirOverride !== undefined) {
+    dirs.push(opencodeConfigDirOverride);
+  }
+  return uniqueStrings(dirs);
+}
+function globSkillFiles(rootDir, subdirNames) {
+  const results = [];
+  for (const subdirName of subdirNames) {
+    const scanRoot = path5.join(rootDir, subdirName);
+    try {
+      if (!fs3.existsSync(scanRoot))
+        continue;
+      const entries = walkDir(scanRoot, {
+        maxDepth: 10,
+        filter: (entry) => !entry.isDirectory && entry.name === "SKILL.md"
+      });
+      for (const entry of entries) {
+        results.push(entry.path);
+      }
+    } catch {}
+  }
+  return results;
+}
+function toDiscoveredSkill(skillPath, rootId) {
+  let content;
+  try {
+    content = fs3.readFileSync(skillPath, "utf8");
+  } catch {
+    return;
+  }
+  const frontmatter = extractFrontmatterFromContent(content);
+  const name = frontmatter.name;
+  if (!name || !isValidSkillName(name))
+    return;
+  return {
+    name,
+    description: frontmatter.description,
+    frontmatter,
+    body: parseFrontmatter(content).body,
+    skillPath,
+    root: rootId
+  };
+}
+function discoverSkills(options) {
+  const { startDir, homeDir, configDir, opencodeConfigDirOverride } = options;
+  const globalConfigDir = configDir ?? path5.join(homeDir, ".config/opencode");
+  const gitRoot = findGitWorktreeRoot(startDir);
+  const byName = new Map;
+  function upsertAll(skillPaths, rootId) {
+    for (const skillPath of skillPaths) {
+      const skill = toDiscoveredSkill(skillPath, rootId);
+      if (skill)
+        byName.set(skill.name, skill);
+    }
+  }
+  upsertAll(globSkillFiles(homeDir, [".claude/skills"]), "global-claude");
+  upsertAll(globSkillFiles(homeDir, [".agents/skills"]), "global-agents");
+  const externalLevels = upWalk([".claude", ".agents"], startDir, gitRoot ?? startDir);
+  for (const levelDir of externalLevels) {
+    const isClaudeDir = path5.basename(levelDir) === ".claude";
+    const parentDir = path5.dirname(levelDir);
+    const subdirGlob = isClaudeDir ? ".claude/skills" : ".agents/skills";
+    const rootId = isClaudeDir ? "project-claude" : "project-agents";
+    upsertAll(globSkillFiles(parentDir, [subdirGlob]), rootId);
+  }
+  const configDirs = buildOpencodeConfigDirs(startDir, homeDir, gitRoot, globalConfigDir, opencodeConfigDirOverride);
+  for (const dir of configDirs) {
+    const rootId = dir === globalConfigDir ? "global-opencode-config" : "project-opencode";
+    upsertAll(globSkillFiles(dir, ["skill", "skills"]), rootId);
+  }
+  return Array.from(byName.values());
+}
+
 // src/lib/model-availability.ts
 import { createHash } from "crypto";
-import fs3 from "fs";
+import fs4 from "fs";
 import os2 from "os";
-import path5 from "path";
+import path6 from "path";
 function emptyAvailability() {
   return { status: "unknown", models: new Set };
 }
@@ -638,8 +769,8 @@ var MODELS_JSON_FILENAME = "models.json";
 var availabilityCache = new WeakMap;
 function resolveCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME?.trim();
-  const cacheBase = xdgCacheHome && path5.isAbsolute(xdgCacheHome) ? xdgCacheHome : path5.join(os2.homedir(), ".cache");
-  return path5.join(cacheBase, "opencode");
+  const cacheBase = xdgCacheHome && path6.isAbsolute(xdgCacheHome) ? xdgCacheHome : path6.join(os2.homedir(), ".cache");
+  return path6.join(cacheBase, "opencode");
 }
 function fastHash(input) {
   return createHash("sha1").update(input).digest("hex");
@@ -658,7 +789,7 @@ function isProviderRecord(value) {
 function readModelsFromCache(filePath) {
   let fd;
   try {
-    fd = fs3.openSync(filePath, "r");
+    fd = fs4.openSync(filePath, "r");
   } catch {
     return null;
   }
@@ -666,7 +797,7 @@ function readModelsFromCache(filePath) {
   try {
     let stat;
     try {
-      stat = fs3.fstatSync(fd);
+      stat = fs4.fstatSync(fd);
     } catch {
       return null;
     }
@@ -681,7 +812,7 @@ function readModelsFromCache(filePath) {
     const buffer = Buffer.alloc(stat.size);
     let bytesRead;
     try {
-      bytesRead = fs3.readSync(fd, buffer, 0, stat.size, 0);
+      bytesRead = fs4.readSync(fd, buffer, 0, stat.size, 0);
     } catch {
       return null;
     }
@@ -690,7 +821,7 @@ function readModelsFromCache(filePath) {
     raw = buffer.toString("utf8");
   } finally {
     try {
-      fs3.closeSync(fd);
+      fs4.closeSync(fd);
     } catch {}
   }
   if (raw.trim().length === 0)
@@ -717,14 +848,14 @@ function readFallbackCache() {
   const cacheDir = resolveCacheDir();
   const openCodeModelsUrl = process.env.OPENCODE_MODELS_URL?.trim();
   if (openCodeModelsUrl) {
-    const urlDerivedPath = path5.join(cacheDir, `models-${fastHash(openCodeModelsUrl)}.json`);
+    const urlDerivedPath = path6.join(cacheDir, `models-${fastHash(openCodeModelsUrl)}.json`);
     const urlResult = readModelsFromCache(urlDerivedPath);
     if (urlResult !== null && urlResult.size > 0) {
       return { status: "cache", models: urlResult };
     }
     return emptyAvailability();
   }
-  const defaultPath = path5.join(cacheDir, MODELS_JSON_FILENAME);
+  const defaultPath = path6.join(cacheDir, MODELS_JSON_FILENAME);
   const defaultResult = readModelsFromCache(defaultPath);
   if (defaultResult !== null && defaultResult.size > 0) {
     return { status: "cache", models: defaultResult };
@@ -1090,12 +1221,59 @@ function collectSkillsAsCommands(dir, disabledSkills) {
   }
   return commands;
 }
+function loadDiscoveredSkillAsCommand(skill) {
+  const description = formatSkillDescription(skill.description, skill.name);
+  if (skill.frontmatter.disableModelInvocation === true) {
+    return {
+      template: wrapSkillTemplate(skill.skillPath, skill.body),
+      description
+    };
+  }
+  return {
+    template: buildDiscoveredSkillShimTemplate(skill.name),
+    description
+  };
+}
+function buildDiscoveredSkillShimTemplate(skillName) {
+  return `Load the "${skillName}" skill using the skill tool, then follow its instructions to address this request:
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
+}
+function collectDiscoveredSkillsAsCommands(startDir, homeDir, configDir, opencodeConfigDirOverride, disabledCommands) {
+  const commands = {};
+  let discovered;
+  try {
+    discovered = discoverSkills({
+      startDir,
+      homeDir,
+      configDir,
+      opencodeConfigDirOverride
+    });
+  } catch {
+    return commands;
+  }
+  for (const skill of discovered) {
+    if (skill.frontmatter.userInvocable === false)
+      continue;
+    if (disabledCommands.includes(skill.name))
+      continue;
+    try {
+      commands[skill.name] = loadDiscoveredSkillAsCommand(skill);
+    } catch {}
+  }
+  return commands;
+}
 function collectEnabledSkillNames(dir, disabledSkills) {
   const disabledSet = new Set(disabledSkills);
   return findSkillsInDir(dir).filter((skillInfo) => !disabledSet.has(skillInfo.name)).map((skillInfo) => skillInfo.name);
 }
 function createConfigHandler(deps) {
   const { directory, bundledSkillsDir, bundledAgentsDir: bundledAgentsDir2, bundledCommandsDir } = deps;
+  const homeDir = deps.homeDir ?? os3.homedir();
+  const opencodeConfigDir = deps.opencodeConfigDir ?? path7.join(homeDir, ".config/opencode");
+  const opencodeConfigDirOverride = process.env.OPENCODE_CONFIG_DIR?.trim() ? process.env.OPENCODE_CONFIG_DIR : undefined;
   return async (config) => {
     const { config: systematicConfig, overlays } = loadConfigWithSources(directory);
     const existingAgents = { ...config.agent ?? {} };
@@ -1116,11 +1294,15 @@ function createConfigHandler(deps) {
     const resolvedOverlays = resolveAgentOverlaySet(validatedOverlays);
     const bundledAgents = collectAgents(bundledAgentsDir2, systematicConfig.disabled_agents, nativeAgents, resolvedOverlays, availabilitySet);
     const bundledCommands = collectCommands(bundledCommandsDir, systematicConfig.disabled_commands);
+    const discoveredSkillCommands = systematicConfig.skills_as_commands !== false ? collectDiscoveredSkillsAsCommands(directory, homeDir, opencodeConfigDir, opencodeConfigDirOverride, systematicConfig.disabled_commands) : {};
     const bundledAgentKeys = new Set(Object.keys(bundledAgents));
     config.agent = mergeSystematicEntries(existingAgents, bundledAgents, (key, agent) => bundledAgentKeys.has(key) && isSystematicAgentConfig(agent));
-    const emittedCommands = { ...bundledCommands, ...bundledSkills };
-    const emittedCommandKeys = new Set(Object.keys(emittedCommands));
-    config.command = mergeSystematicEntries(existingCommands, emittedCommands, (key, command) => isSystematicCommandConfig(command) && (emittedCommandKeys.has(key) || isSystematicOwnedCommandKey(key)));
+    const emittedCommands = {
+      ...bundledCommands,
+      ...bundledSkills,
+      ...discoveredSkillCommands
+    };
+    config.command = mergeSystematicEntries(existingCommands, emittedCommands, (_key, command) => isSystematicCommandConfig(command));
     registerSkillsPaths(config, bundledSkillsDir);
   };
 }
@@ -1136,22 +1318,19 @@ function registerSkillsPaths(config, skillsDir) {
   };
 }
 function removeSystematicSkillPaths(paths) {
-  return paths.filter((path6) => !isSystematicSkillPath(path6));
+  return paths.filter((path8) => !isSystematicSkillPath(path8));
 }
-function isSystematicSkillPath(path6) {
-  const normalizedPath = normalizePath(path6);
+function isSystematicSkillPath(path8) {
+  const normalizedPath = normalizePath(path8);
   return normalizedPath.endsWith("/.config/opencode/systematic/skills") || normalizedPath.endsWith("/.cache/opencode/systematic/skills") || normalizedPath.endsWith("/.local/share/opencode/systematic/skills") || normalizedPath.endsWith("/.opencode/systematic/skills") || /(?:^|\/)\.cache\/opencode\/packages\/@fro\.bot\/systematic@[^/]+\/node_modules\/@fro\.bot\/systematic\/skills(?:$|\/)/u.test(normalizedPath);
 }
-function normalizePath(path6) {
-  return path6.replaceAll("\\", "/").replace(/\/+$/u, "");
-}
-function isSystematicOwnedCommandKey(key) {
-  return key.startsWith("systematic:") || key.startsWith("ce:");
+function normalizePath(path8) {
+  return path8.replaceAll("\\", "/").replace(/\/+$/u, "");
 }
 
 // src/lib/skill-tool.ts
-import fs4 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path8 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { tool } from "@opencode-ai/plugin/tool";
 function discoverSkillFiles(dir, limit = 10) {
@@ -1165,17 +1344,17 @@ function discoverSkillFiles(dir, limit = 10) {
   function handleEntry(entry, currentDir) {
     if (entry.isDirectory()) {
       if (!shouldSkipDirectory(entry.name)) {
-        recurse(path6.resolve(currentDir, entry.name));
+        recurse(path8.resolve(currentDir, entry.name));
       }
     } else if (shouldIncludeFile(entry.name)) {
-      files.push(path6.resolve(currentDir, entry.name));
+      files.push(path8.resolve(currentDir, entry.name));
     }
   }
   function recurse(currentDir) {
     if (files.length >= limit)
       return;
     try {
-      const entries = fs4.readdirSync(currentDir, { withFileTypes: true });
+      const entries = fs5.readdirSync(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (files.length >= limit)
           break;
@@ -1261,7 +1440,7 @@ ${catalog}`;
         warnedSkills.add(matchedSkill.name);
       }
       const body = extractSkillBody(matchedSkill.wrappedTemplate);
-      const dir = path6.dirname(matchedSkill.skillFile);
+      const dir = path8.dirname(matchedSkill.skillFile);
       const base = pathToFileURL2(dir).href;
       const files = discoverSkillFiles(dir);
       await context.ask({
@@ -1298,17 +1477,17 @@ ${catalog}`;
 }
 
 // src/index.ts
-var __dirname3 = path7.dirname(fileURLToPath2(import.meta.url));
-var packageRoot2 = path7.resolve(__dirname3, "..");
-var bundledSkillsDir = path7.join(packageRoot2, "skills");
-var bundledAgentsDir2 = path7.join(packageRoot2, "agents");
-var bundledCommandsDir = path7.join(packageRoot2, "commands");
-var packageJsonPath = path7.join(packageRoot2, "package.json");
+var __dirname3 = path9.dirname(fileURLToPath2(import.meta.url));
+var packageRoot2 = path9.resolve(__dirname3, "..");
+var bundledSkillsDir = path9.join(packageRoot2, "skills");
+var bundledAgentsDir2 = path9.join(packageRoot2, "agents");
+var bundledCommandsDir = path9.join(packageRoot2, "commands");
+var packageJsonPath = path9.join(packageRoot2, "package.json");
 var getPackageVersion = () => {
   try {
-    if (!fs5.existsSync(packageJsonPath))
+    if (!fs6.existsSync(packageJsonPath))
       return "unknown";
-    const content = fs5.readFileSync(packageJsonPath, "utf8");
+    const content = fs6.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(content);
     return parsed.version ?? "unknown";
   } catch {

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

@@ -7,6 +7,10 @@ export interface ConfigHandlerDeps {
     bundledCommandsDir: string;
     /** OpenCode client for availability lookup. When omitted, availability falls back to empty set (last-resort resolution). */
     client?: OpencodeClientLike;
+    /** Home directory for discovered-skill lookups. Defaults to `os.homedir()`; inject a temp dir in tests. */
+    homeDir?: string;
+    /** OpenCode global config directory override for discovered-skill lookups. Defaults to `<homeDir>/.config/opencode`. */
+    opencodeConfigDir?: string;
 }
 export declare function toTitleCase(name: string): string;
 export declare function formatAgentDescription(name: string, description: string | undefined): string;

package/dist/lib/config.d.ts

@@ -24,6 +24,7 @@ export interface SystematicConfig {
     bootstrap: BootstrapConfig;
     agents?: OverlayConfigMap;
     categories?: OverlayConfigMap;
+    skills_as_commands: boolean;
 }
 export declare const DEFAULT_CONFIG: SystematicConfig;
 /**

package/dist/lib/discovered-skills.d.ts

@@ -0,0 +1,70 @@
+import { type SkillFrontmatter } from './skills.js';
+/**
+ * Provenance ids for discovered skills. When the same skill `name` is found
+ * in multiple roots, the winner is whichever root is discovered LAST in
+ * upstream's sequence (mirrors upstream `skill/index.ts`'s last-write-wins
+ * map keyed by frontmatter name). Discovery order (earliest to latest):
+ * global-claude, global-agents, project-claude/project-agents (walked from
+ * startDir up to the worktree root, closest-first), then all
+ * `.opencode`-style config directories (global-opencode-config wins over
+ * everything above it). Do not reorder without re-verifying against
+ * upstream.
+ */
+type DiscoveryRootId = 'global-claude' | 'global-agents' | 'project-claude' | 'project-agents' | 'project-opencode' | 'global-opencode-config';
+export interface DiscoveredSkill {
+    name: string;
+    description: string;
+    frontmatter: SkillFrontmatter;
+    /** SKILL.md body (frontmatter stripped), read once at discovery so callers
+     * that inline the body don't re-read the file. */
+    body: string;
+    skillPath: string;
+    root: DiscoveryRootId;
+}
+export interface DiscoverSkillsOptions {
+    /** Directory to start the upward worktree walk from (typically the project cwd). */
+    startDir: string;
+    /** Home directory, injected so tests can use a temp dir instead of the real one. */
+    homeDir: string;
+    /**
+     * Override for OpenCode's global config directory (mirrors
+     * `$XDG_CONFIG_HOME` resolution). Defaults to `<homeDir>/.config/opencode`
+     * when omitted.
+     */
+    configDir?: string;
+    /**
+     * Override mirroring upstream's `OPENCODE_CONFIG_DIR` env var: an extra
+     * config directory appended to the end of the OpenCode config-dir list
+     * (so it wins over every other root, including the default global config
+     * dir). Injected as a param rather than read from `process.env` to keep
+     * discovery pure and testable.
+     */
+    opencodeConfigDirOverride?: string;
+}
+/**
+ * Discover user/project skills, replicating OpenCode v1.17.6's real
+ * discovery algorithm (verified from source: `skill/index.ts`,
+ * `config/paths.ts`, `util/filesystem.ts`). Builds ONE map keyed by
+ * frontmatter skill `name`; entries are scanned and upserted in upstream's
+ * exact sequence, and later additions overwrite earlier ones:
+ *
+ *   1. Global external: `<home>/.claude/skills/**\/SKILL.md`, then
+ *      `<home>/.agents/skills/**\/SKILL.md`.
+ *   2. Project external (multi-level up-walk): from `startDir` up to the
+ *      git worktree root (inclusive), closest-first; at each level scan
+ *      `.claude/skills/**\/SKILL.md` then `.agents/skills/**\/SKILL.md`.
+ *      Because of last-write-wins, the worktree-root level wins over
+ *      deeper subdirectories.
+ *   3. OpenCode config dirs (`ConfigPaths.directories`-equivalent: global
+ *      config dir, then project `.opencode` up-walk, then `<home>/.opencode`,
+ *      then an optional `OPENCODE_CONFIG_DIR`-style override), each scanned
+ *      for `{skill,skills}/**\/SKILL.md`. Scanned last, so these beat
+ *      everything above.
+ *
+ * The dedup key is the frontmatter `name` (not the containing directory
+ * name); entries with no name, or a name failing the charset/length regex,
+ * are skipped. Never throws: unreadable dirs/files, missing roots, or
+ * malformed frontmatter cause that entry to be skipped, not an abort.
+ */
+export declare function discoverSkills(options: DiscoverSkillsOptions): DiscoveredSkill[];
+export {};

package/dist/lib/skills.d.ts

@@ -37,5 +37,11 @@ export interface SkillInfo {
     allowedTools?: string;
 }
 export declare const SKILL_FRONTMATTER_FIELDS: readonly ["name", "description", "argument-hint", "disable-model-invocation", "allowed-tools", "license", "compatibility", "metadata", "deprecated", "user-invocable", "agent", "model", "context", "subtask"];
+/**
+ * Parse skill frontmatter from already-read file content. Split out from
+ * `extractFrontmatter` so callers that also need the body (e.g. discovered-skill
+ * command emission) can read the file once and derive both. Never throws.
+ */
+export declare function extractFrontmatterFromContent(content: string): SkillFrontmatter;
 export declare function extractFrontmatter(filePath: string): SkillFrontmatter;
 export declare function findSkillsInDir(dir: string, maxDepth?: number): SkillInfo[];

package/dist/schemas/systematic-config.schema.json

@@ -22,6 +22,9 @@
     },
     "bootstrap": {
       "$ref": "#/definitions/__schema51"
+    },
+    "skills_as_commands": {
+      "$ref": "#/definitions/__schema57"
     }
   },
   "additionalProperties": false,
@@ -1504,6 +1507,19 @@
     },
     "__schema56": {
       "type": "string"
+    },
+    "__schema57": {
+      "default": true,
+      "description": "Register skills discovered from user/project skill directories (OpenCode config and other agent-harness-standard locations) as slash commands. Default true.",
+      "examples": [true, false],
+      "allOf": [
+        {
+          "$ref": "#/definitions/__schema58"
+        }
+      ]
+    },
+    "__schema58": {
+      "type": "boolean"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "2.32.2",
+  "version": "2.33.1",
   "description": "Structured engineering workflows for OpenCode",
   "type": "module",
   "homepage": "https://fro.bot/systematic",