@fro.bot/systematic 3.8.0 → 3.9.1

package/dist/index.js

@@ -14,125 +14,18 @@ import {
   loadConfig,
   loadConfigWithSources,
   parseFrontmatter
-} from "./index-hjbt4p5s.js";
+} from "./index-y8nc60tz.js";
 
 // src/index.ts
 import { createHash as createHash5 } from "crypto";
 import fs11 from "fs";
 import path10 from "path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "url";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "url";
 
 // src/lib/bootstrap.ts
-import fs3 from "fs";
-import os from "os";
-import path2 from "path";
-
-// src/lib/skill-catalog.ts
-import { pathToFileURL } from "url";
-
-// src/lib/skill-loader.ts
 import fs2 from "fs";
+import os from "os";
 import path from "path";
-var SKILL_PREFIX = "systematic:";
-var SKILL_DESCRIPTION_PREFIX = "(Systematic) ";
-function formatSkillCommandName(name2) {
-  if (name2.includes(":")) {
-    return name2;
-  }
-  return `${SKILL_PREFIX}${name2}`;
-}
-function formatSkillDescription(description, fallbackName) {
-  const desc = description || `${fallbackName} skill`;
-  if (desc.startsWith(SKILL_DESCRIPTION_PREFIX)) {
-    return desc;
-  }
-  return `${SKILL_DESCRIPTION_PREFIX}${desc}`;
-}
-function wrapSkillTemplate(skillPath, body2) {
-  const skillDir = path.dirname(skillPath);
-  return `<skill-instruction>
-Base directory for this skill: ${skillDir}/
-File references (@path) in this skill are relative to this directory.
-
-${body2.trim()}
-</skill-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`;
-}
-function extractSkillBody(wrappedTemplate) {
-  const match = wrappedTemplate.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
-  return match ? match[1].trim() : wrappedTemplate;
-}
-function loadSkill(skillInfo) {
-  try {
-    const content = fs2.readFileSync(skillInfo.skillFile, "utf8");
-    const { body: body2 } = parseFrontmatter(content);
-    const wrappedTemplate = wrapSkillTemplate(skillInfo.skillFile, body2);
-    return {
-      name: skillInfo.name,
-      prefixedName: formatSkillCommandName(skillInfo.name),
-      description: formatSkillDescription(skillInfo.description, skillInfo.name),
-      path: skillInfo.path,
-      skillFile: skillInfo.skillFile,
-      wrappedTemplate,
-      disableModelInvocation: skillInfo.disableModelInvocation,
-      userInvocable: skillInfo.userInvocable,
-      subtask: skillInfo.subtask,
-      agent: skillInfo.agent,
-      model: skillInfo.model,
-      argumentHint: skillInfo.argumentHint
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/lib/skill-catalog.ts
-function escapeXml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function buildCatalogEntries(options) {
-  const { bundledSkillsDir, disabledSkills } = options;
-  return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).filter((s) => s.disableModelInvocation !== true).sort((a, b) => a.name.localeCompare(b.name)).map((s) => ({
-    name: s.name,
-    prefixedName: formatSkillCommandName(s.name),
-    description: s.description,
-    path: s.path,
-    skillFile: s.skillFile
-  }));
-}
-function renderCatalogVerbose(options) {
-  const entries = buildCatalogEntries(options);
-  if (entries.length === 0)
-    return "";
-  const skillLines = entries.flatMap((entry) => [
-    "  <skill>",
-    `    <name>${escapeXml(entry.prefixedName)}</name>`,
-    `    <description>${escapeXml(entry.description)}</description>`,
-    `    <location>${pathToFileURL(entry.path).href}</location>`,
-    "  </skill>"
-  ]);
-  return ["<available_skills>", ...skillLines, "</available_skills>"].join(`
-`);
-}
-function renderCatalogCompact(options) {
-  const entries = buildCatalogEntries(options);
-  const heading = "## Available Systematic Skills";
-  if (entries.length === 0) {
-    return `${heading}
-
-No Systematic skills are currently available.`;
-  }
-  const bullets = entries.map((entry) => `- ${entry.prefixedName}: ${entry.description}`).join(`
-`);
-  return `${heading}
-
-${bullets}`;
-}
-
-// src/lib/bootstrap.ts
 var INTERNAL_AGENT_SIGNATURES = [
   "You are a title generator",
   "You are a helpful AI assistant tasked with summarizing conversations",
@@ -190,9 +83,9 @@ var applyBootstrapContent = (output, content) => {
 ${content}` : content;
 };
 function readHarnessProfile(bundledSkillsDir, name2) {
-  const profilePath = path2.join(bundledSkillsDir, "using-systematic/references", `${name2}-profile.md`);
+  const profilePath = path.join(bundledSkillsDir, "using-systematic/references", `${name2}-profile.md`);
   try {
-    return fs3.readFileSync(profilePath, "utf8");
+    return fs2.readFileSync(profilePath, "utf8");
   } catch (error) {
     console.error(`Failed to read harness profile ${profilePath}: ${error instanceof Error ? error.message : String(error)}`);
     return null;
@@ -216,25 +109,18 @@ function getBootstrapContent(config, deps) {
   if (!config.bootstrap.enabled)
     return null;
   if (config.bootstrap.file) {
-    const customPath = config.bootstrap.file.startsWith("~/") ? path2.join(os.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
-    if (fs3.existsSync(customPath)) {
-      return fs3.readFileSync(customPath, "utf8");
+    const customPath = config.bootstrap.file.startsWith("~/") ? path.join(os.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
+    if (fs2.existsSync(customPath)) {
+      return fs2.readFileSync(customPath, "utf8");
     }
   }
-  const usingSystematicPath = path2.join(bundledSkillsDir, "using-systematic/SKILL.md");
-  if (!fs3.existsSync(usingSystematicPath))
+  const usingSystematicPath = path.join(bundledSkillsDir, "using-systematic/SKILL.md");
+  if (!fs2.existsSync(usingSystematicPath))
     return null;
-  const fullContent = fs3.readFileSync(usingSystematicPath, "utf8");
+  const fullContent = fs2.readFileSync(usingSystematicPath, "utf8");
   const { body: body2 } = parseFrontmatter(fullContent);
   const content = body2.trim();
   const skillUsage = usageTemplate ?? getSkillUsageTemplate();
-  const catalog = renderCatalogVerbose({
-    bundledSkillsDir,
-    disabledSkills: config.disabled_skills
-  });
-  const catalogSection = catalog.length > 0 ? `
-
-${catalog}` : "";
   const profileSection = profileBlock === undefined ? "" : `
 
 ${profileBlock}`;
@@ -245,7 +131,7 @@ You have access to structured engineering workflows via the Systematic plugin.
 
 ${content}
 
-${skillUsage}${profileSection}${catalogSection}
+${skillUsage}${profileSection}
 </SYSTEMATIC_WORKFLOWS>`;
 }
 
@@ -255,16 +141,16 @@ import os3 from "os";
 import path6 from "path";
 
 // src/lib/agent-overlays.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path3 from "path";
 
 // src/lib/source-model-defaults.ts
-import * as path3 from "path";
+import * as path2 from "path";
 import { fileURLToPath } from "url";
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path3.dirname(__filename2);
-var packageRoot = path3.resolve(__dirname2, "..", "..");
-var bundledAgentsDir = path3.join(packageRoot, "agents");
+var __dirname2 = path2.dirname(__filename2);
+var packageRoot = path2.resolve(__dirname2, "..", "..");
+var bundledAgentsDir = path2.join(packageRoot, "agents");
 var ProviderID = exports_external.union([
   exports_external.literal("vercel"),
   exports_external.literal("opencode"),
@@ -453,14 +339,14 @@ function buildBundledAgentInventory(agentsDir, disabledAgents) {
   const stemCategories = new Map;
   const disabledSet = new Set(disabledAgents);
   for (const category of categories) {
-    for (const fileName of readMarkdownFiles(path4.join(agentsDir, category))) {
+    for (const fileName of readMarkdownFiles(path3.join(agentsDir, category))) {
       const key = fileName.replace(/\.md$/, "");
       const id = `${category}/${key}`;
       agentsByQualifiedId[id] = {
         id,
         key,
         category,
-        file: path4.join(agentsDir, category, fileName),
+        file: path3.join(agentsDir, category, fileName),
         disabled: disabledSet.has(key) || disabledSet.has(id)
       };
       const existing = stemCategories.get(key) ?? [];
@@ -585,14 +471,14 @@ function validateOverlaySkills(overlay, skills, enabledSkills) {
 }
 function readCategoryDirs(agentsDir) {
   try {
-    return fs4.readdirSync(agentsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    return fs3.readdirSync(agentsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
   } catch {
     return [];
   }
 }
 function readMarkdownFiles(categoryDir) {
   try {
-    return fs4.readdirSync(categoryDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort();
+    return fs3.readdirSync(categoryDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort();
   } catch {
     return [];
   }
@@ -606,9 +492,9 @@ function throwConfigError(sourcePath, keyPath, message) {
 
 // src/lib/model-availability.ts
 import { createHash } from "crypto";
-import fs5 from "fs";
+import fs4 from "fs";
 import os2 from "os";
-import path5 from "path";
+import path4 from "path";
 function emptyAvailability() {
   return { status: "unknown", models: new Set };
 }
@@ -618,8 +504,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 && path4.isAbsolute(xdgCacheHome) ? xdgCacheHome : path4.join(os2.homedir(), ".cache");
+  return path4.join(cacheBase, "opencode");
 }
 function fastHash(input) {
   return createHash("sha1").update(input).digest("hex");
@@ -638,7 +524,7 @@ function isProviderRecord(value) {
 function readModelsFromCache(filePath) {
   let fd;
   try {
-    fd = fs5.openSync(filePath, "r");
+    fd = fs4.openSync(filePath, "r");
   } catch {
     return null;
   }
@@ -646,7 +532,7 @@ function readModelsFromCache(filePath) {
   try {
     let stat;
     try {
-      stat = fs5.fstatSync(fd);
+      stat = fs4.fstatSync(fd);
     } catch {
       return null;
     }
@@ -661,7 +547,7 @@ function readModelsFromCache(filePath) {
     const buffer = Buffer.alloc(stat.size);
     let bytesRead;
     try {
-      bytesRead = fs5.readSync(fd, buffer, 0, stat.size, 0);
+      bytesRead = fs4.readSync(fd, buffer, 0, stat.size, 0);
     } catch {
       return null;
     }
@@ -670,7 +556,7 @@ function readModelsFromCache(filePath) {
     raw = buffer.toString("utf8");
   } finally {
     try {
-      fs5.closeSync(fd);
+      fs4.closeSync(fd);
     } catch {}
   }
   if (raw.trim().length === 0)
@@ -697,14 +583,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 = path4.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 = path4.join(cacheDir, MODELS_JSON_FILENAME);
   const defaultResult = readModelsFromCache(defaultPath);
   if (defaultResult !== null && defaultResult.size > 0) {
     return { status: "cache", models: defaultResult };
@@ -769,6 +655,65 @@ async function getAvailableModels(client, options = {}) {
   });
 }
 
+// src/lib/skill-loader.ts
+import fs5 from "fs";
+import path5 from "path";
+var SKILL_PREFIX = "systematic:";
+var SKILL_DESCRIPTION_PREFIX = "(Systematic) ";
+function formatSkillCommandName(name2) {
+  if (name2.includes(":")) {
+    return name2;
+  }
+  return `${SKILL_PREFIX}${name2}`;
+}
+function formatSkillDescription(description, fallbackName) {
+  const desc = description || `${fallbackName} skill`;
+  if (desc.startsWith(SKILL_DESCRIPTION_PREFIX)) {
+    return desc;
+  }
+  return `${SKILL_DESCRIPTION_PREFIX}${desc}`;
+}
+function wrapSkillTemplate(skillPath, body2) {
+  const skillDir = path5.dirname(skillPath);
+  return `<skill-instruction>
+Base directory for this skill: ${skillDir}/
+File references (@path) in this skill are relative to this directory.
+
+${body2.trim()}
+</skill-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
+}
+function extractSkillBody(wrappedTemplate) {
+  const match = wrappedTemplate.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
+  return match ? match[1].trim() : wrappedTemplate;
+}
+function loadSkill(skillInfo) {
+  try {
+    const content = fs5.readFileSync(skillInfo.skillFile, "utf8");
+    const { body: body2 } = parseFrontmatter(content);
+    const wrappedTemplate = wrapSkillTemplate(skillInfo.skillFile, body2);
+    return {
+      name: skillInfo.name,
+      prefixedName: formatSkillCommandName(skillInfo.name),
+      description: formatSkillDescription(skillInfo.description, skillInfo.name),
+      path: skillInfo.path,
+      skillFile: skillInfo.skillFile,
+      wrappedTemplate,
+      disableModelInvocation: skillInfo.disableModelInvocation,
+      userInvocable: skillInfo.userInvocable,
+      subtask: skillInfo.subtask,
+      agent: skillInfo.agent,
+      model: skillInfo.model,
+      argumentHint: skillInfo.argumentHint
+    };
+  } catch {
+    return null;
+  }
+}
+
 // src/lib/config-handler.ts
 function isSystematicAgentConfig(agent) {
   const description = agent?.description;
@@ -13381,7 +13326,33 @@ function createOpencodeWorkflowGuard(options) {
 // src/lib/skill-resolver.ts
 import fs10 from "fs";
 import path9 from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
+import { pathToFileURL } from "url";
+
+// src/lib/skill-catalog.ts
+function buildCatalogEntries(options) {
+  const { bundledSkillsDir, disabledSkills } = options;
+  return findSkillsInDir(bundledSkillsDir).filter((s) => !disabledSkills.includes(s.name)).filter((s) => s.disableModelInvocation !== true).sort((a, b) => a.name.localeCompare(b.name)).map((s) => ({
+    name: s.name,
+    prefixedName: formatSkillCommandName(s.name),
+    description: s.description
+  }));
+}
+function renderCatalogCompact(options) {
+  const entries = buildCatalogEntries(options);
+  const heading = "## Available Systematic Skills";
+  if (entries.length === 0) {
+    return `${heading}
+
+No Systematic skills are currently available.`;
+  }
+  const bullets = entries.map((entry) => `- ${entry.prefixedName}: ${entry.description}`).join(`
+`);
+  return `${heading}
+
+${bullets}`;
+}
+
+// src/lib/skill-resolver.ts
 function getAllSkills(options) {
   const { bundledSkillsDir, disabledSkills } = options;
   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));
@@ -13417,7 +13388,7 @@ function buildSkillToolParameterHint(options) {
 function buildSkillContentOutput(matchedSkill) {
   const body2 = extractSkillBody(matchedSkill.wrappedTemplate);
   const dir = path9.dirname(matchedSkill.skillFile);
-  const base = pathToFileURL2(dir).href;
+  const base = pathToFileURL(dir).href;
   const files = discoverSkillFiles(dir);
   const lines = [
     `<skill_content name="${matchedSkill.prefixedName}">`,
@@ -13469,6 +13440,7 @@ function discoverSkillFiles(dir, limit = 10) {
   return files.map((file) => `  <file>${file}</file>`).join(`
 `);
 }
+
 // src/lib/skill-tool.ts
 function createSkillTool(options) {
   const { bundledSkillsDir, disabledSkills } = options;
@@ -13520,7 +13492,7 @@ var bundledSkillsDir = path10.join(packageRoot2, "skills");
 var bundledAgentsDir2 = path10.join(packageRoot2, "agents");
 var bundledCommandsDir = path10.join(packageRoot2, "commands");
 var packageJsonPath = path10.join(packageRoot2, "package.json");
-var canonicalPackageSource = pathToFileURL3(fs11.realpathSync(packageRoot2)).href;
+var canonicalPackageSource = pathToFileURL2(fs11.realpathSync(packageRoot2)).href;
 var registrationSourceIdentity = createHash5("sha256").update(`systematic/opencode-registration-source/v1/${canonicalPackageSource}`).digest("hex");
 var getPackageVersion = () => {
   try {

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

@@ -1,15 +1,7 @@
-/**
- * Escape XML special characters (&, <, >) in text content.
- * Quotes are not escaped because catalog names and descriptions are rendered
- * as element text, not attribute values.
- */
-export declare function escapeXml(text: string): string;
 export interface CatalogEntry {
     name: string;
     prefixedName: string;
     description: string;
-    path: string;
-    skillFile: string;
 }
 export interface CatalogOptions {
     bundledSkillsDir: string;
@@ -21,11 +13,6 @@ export interface CatalogOptions {
  * Returns entries sorted by name.
  */
 export declare function buildCatalogEntries(options: CatalogOptions): CatalogEntry[];
-/**
- * Renders discoverable skills as native-style verbose XML for bootstrap content.
- * Returns empty string when no skills are available.
- */
-export declare function renderCatalogVerbose(options: CatalogOptions): string;
 /**
  * Renders discoverable skills as a compact markdown list for tool descriptions.
  * Always includes the heading; renders an explicit no-skills message when empty.

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

@@ -1,13 +1,7 @@
 import type { ToolDefinition } from '@opencode-ai/plugin';
-import type { SkillInfo } from './skills.js';
 export { discoverSkillFiles } from './skill-resolver.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;