@fro.bot/systematic 1.2.1 → 1.3.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -4,8 +4,9 @@ import {
   convertContent,
   findAgentsInDir,
   findCommandsInDir,
-  findSkillsInDir
-} from "./index-hkk4125w.js";
+  findSkillsInDir,
+  getConfigPaths
+} from "./index-ymsavt2y.js";
 
 // src/cli.ts
 import fs from "fs";
@@ -37,12 +38,6 @@ Examples:
   systematic convert skill ./skills/my-skill/SKILL.md
   systematic config show
 `;
-function getUserConfigDir() {
-  return path.join(process.env.HOME || process.env.USERPROFILE || ".", ".config/opencode");
-}
-function getProjectConfigDir() {
-  return path.join(process.cwd(), ".opencode");
-}
 function listItems(type) {
   const packageRoot = path.resolve(import.meta.dirname, "..");
   const bundledDir = packageRoot;
@@ -65,7 +60,7 @@ function listItems(type) {
       console.error(`Unknown type: ${type}. Use: skills, agents, commands`);
       process.exit(1);
   }
-  const items = finder(path.join(bundledDir, subdir), "bundled");
+  const items = finder(path.join(bundledDir, subdir));
   if (items.length === 0) {
     console.log(`No ${type} found.`);
     return;
@@ -73,7 +68,7 @@ function listItems(type) {
   console.log(`Available ${type}:
 `);
   for (const item of items.sort((a, b) => a.name.localeCompare(b.name))) {
-    console.log(`  ${item.name} (${item.sourceType})`);
+    console.log(`  ${item.name}`);
   }
 }
 function runConvert(type, filePath, modeArg) {
@@ -102,31 +97,27 @@ function runConvert(type, filePath, modeArg) {
   console.log(converted);
 }
 function configShow() {
-  const userDir = getUserConfigDir();
-  const projectDir = getProjectConfigDir();
+  const paths = getConfigPaths(process.cwd());
   console.log(`Configuration locations:
 `);
-  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(`  User config:    ${paths.userConfig}`);
+  console.log(`  Project config: ${paths.projectConfig}`);
+  if (fs.existsSync(paths.projectConfig)) {
     console.log(`
 Project configuration:`);
-    console.log(fs.readFileSync(projectConfig, "utf-8"));
+    console.log(fs.readFileSync(paths.projectConfig, "utf-8"));
   }
-  const userConfig = path.join(userDir, "systematic.json");
-  if (fs.existsSync(userConfig)) {
+  if (fs.existsSync(paths.userConfig)) {
     console.log(`
 User configuration:`);
-    console.log(fs.readFileSync(userConfig, "utf-8"));
+    console.log(fs.readFileSync(paths.userConfig, "utf-8"));
   }
 }
 function configPath() {
-  const userDir = getUserConfigDir();
-  const projectDir = getProjectConfigDir();
+  const paths = getConfigPaths(process.cwd());
   console.log("Config file paths:");
-  console.log(`  User:    ${path.join(userDir, "systematic.json")}`);
-  console.log(`  Project: ${path.join(projectDir, "systematic.json")}`);
+  console.log(`  User:    ${paths.userConfig}`);
+  console.log(`  Project: ${paths.projectConfig}`);
 }
 var args = process.argv.slice(2);
 var command = args[0];

package/dist/index-ymsavt2y.js

@@ -0,0 +1,404 @@
+// @bun
+// src/lib/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { parse as parseJsonc } from "jsonc-parser";
+var DEFAULT_CONFIG = {
+  disabled_skills: [],
+  disabled_agents: [],
+  disabled_commands: [],
+  bootstrap: {
+    enabled: true
+  }
+};
+function loadJsoncFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath))
+      return null;
+    const content = fs.readFileSync(filePath, "utf-8");
+    return parseJsonc(content);
+  } catch {
+    return null;
+  }
+}
+function mergeArraysUnique(arr1, arr2) {
+  const set = new Set;
+  if (arr1)
+    for (const item of arr1)
+      set.add(item);
+  if (arr2)
+    for (const item of arr2)
+      set.add(item);
+  return Array.from(set);
+}
+function loadConfig(projectDir) {
+  const homeDir = os.homedir();
+  const userConfigPath = path.join(homeDir, ".config/opencode/systematic.json");
+  const projectConfigPath = path.join(projectDir, ".opencode/systematic.json");
+  const userConfig = loadJsoncFile(userConfigPath);
+  const projectConfig = loadJsoncFile(projectConfigPath);
+  const result = {
+    disabled_skills: mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_skills, userConfig?.disabled_skills), projectConfig?.disabled_skills),
+    disabled_agents: mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_agents, userConfig?.disabled_agents), projectConfig?.disabled_agents),
+    disabled_commands: mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_commands, userConfig?.disabled_commands), projectConfig?.disabled_commands),
+    bootstrap: {
+      ...DEFAULT_CONFIG.bootstrap,
+      ...userConfig?.bootstrap,
+      ...projectConfig?.bootstrap
+    }
+  };
+  return result;
+}
+function getConfigPaths(projectDir) {
+  const homeDir = os.homedir();
+  return {
+    userConfig: path.join(homeDir, ".config/opencode/systematic.json"),
+    projectConfig: path.join(projectDir, ".opencode/systematic.json"),
+    userDir: path.join(homeDir, ".config/opencode/systematic"),
+    projectDir: path.join(projectDir, ".opencode/systematic")
+  };
+}
+
+// src/lib/frontmatter.ts
+import yaml from "js-yaml";
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n?---\r?\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return {
+      data: {},
+      body: content,
+      hadFrontmatter: false,
+      parseError: false
+    };
+  }
+  const yamlContent = match[1];
+  const body = match[2];
+  try {
+    const parsed = yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA });
+    const data = parsed ?? {};
+    return { data, body, hadFrontmatter: true, parseError: false };
+  } catch {
+    return { data: {}, body, hadFrontmatter: true, parseError: true };
+  }
+}
+function formatFrontmatter(data) {
+  if (Object.keys(data).length === 0) {
+    return ["---", "---"].join(`
+`);
+  }
+  const yamlContent = yaml.dump(data, {
+    schema: yaml.JSON_SCHEMA,
+    lineWidth: -1,
+    noRefs: true
+  }).trimEnd();
+  return ["---", yamlContent, "---"].join(`
+`);
+}
+function stripFrontmatter(content) {
+  const { body, hadFrontmatter } = parseFrontmatter(content);
+  return hadFrontmatter ? body.trim() : content.trim();
+}
+
+// src/lib/walk-dir.ts
+import fs2 from "fs";
+import path2 from "path";
+function walkDir(rootDir, options = {}) {
+  const { maxDepth = 3, filter } = options;
+  const results = [];
+  if (!fs2.existsSync(rootDir))
+    return results;
+  function recurse(currentDir, depth, category) {
+    if (depth > maxDepth)
+      return;
+    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(currentDir, entry.name);
+      const walkEntry = {
+        path: fullPath,
+        name: entry.name,
+        isDirectory: entry.isDirectory(),
+        depth,
+        category
+      };
+      if (!filter || filter(walkEntry)) {
+        results.push(walkEntry);
+      }
+      if (entry.isDirectory()) {
+        recurse(fullPath, depth + 1, entry.name);
+      }
+    }
+  }
+  recurse(rootDir, 0);
+  return results;
+}
+
+// src/lib/agents.ts
+function findAgentsInDir(dir, maxDepth = 2) {
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => !e.isDirectory && e.name.endsWith(".md")
+  });
+  return entries.map((entry) => ({
+    name: entry.name.replace(/\.md$/, ""),
+    file: entry.path,
+    category: entry.category
+  }));
+}
+function extractAgentFrontmatter(content) {
+  const { data, parseError } = parseFrontmatter(content);
+  return {
+    name: !parseError && typeof data.name === "string" ? data.name : "",
+    description: !parseError && typeof data.description === "string" ? data.description : "",
+    prompt: stripFrontmatter(content)
+  };
+}
+
+// src/lib/commands.ts
+function findCommandsInDir(dir, maxDepth = 2) {
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => !e.isDirectory && e.name.endsWith(".md")
+  });
+  return entries.map((entry) => {
+    const baseName = entry.name.replace(/\.md$/, "");
+    const commandName = entry.category ? `/${entry.category}:${baseName}` : `/${baseName}`;
+    return {
+      name: commandName,
+      file: entry.path,
+      category: entry.category
+    };
+  });
+}
+function extractCommandFrontmatter(content) {
+  const { data, parseError } = parseFrontmatter(content);
+  const argumentHintRaw = !parseError && typeof data["argument-hint"] === "string" ? data["argument-hint"] : "";
+  return {
+    name: !parseError && typeof data.name === "string" ? data.name : "",
+    description: !parseError && typeof data.description === "string" ? data.description : "",
+    argumentHint: argumentHintRaw.replace(/^["']|["']$/g, "")
+  };
+}
+
+// src/lib/converter.ts
+import fs3 from "fs";
+var cache = new Map;
+var TOOL_MAPPINGS = [
+  [/\bTask\s+tool\b/gi, "delegate_task tool"],
+  [/\bTask\s+([\w-]+)\s*\(/g, "delegate_task $1("],
+  [/\bTask\s*\(/g, "delegate_task("],
+  [/\bTask\b(?=\s+to\s+\w)/g, "delegate_task"],
+  [/\bTodoWrite\b/g, "todowrite"],
+  [/\bAskUserQuestion\b/g, "question"],
+  [/\bWebSearch\b/g, "google_search"],
+  [/\bRead\b(?=\s+tool|\s+to\s+|\()/g, "read"],
+  [/\bWrite\b(?=\s+tool|\s+to\s+|\()/g, "write"],
+  [/\bEdit\b(?=\s+tool|\s+to\s+|\()/g, "edit"],
+  [/\bBash\b(?=\s+tool|\s+to\s+|\()/g, "bash"],
+  [/\bGrep\b(?=\s+tool|\s+to\s+|\()/g, "grep"],
+  [/\bGlob\b(?=\s+tool|\s+to\s+|\()/g, "glob"],
+  [/\bWebFetch\b/g, "webfetch"],
+  [/\bSkill\b(?=\s+tool)/g, "skill"]
+];
+var PATH_REPLACEMENTS = [
+  [/\.claude\/skills\//g, ".opencode/skills/"],
+  [/\.claude\/commands\//g, ".opencode/commands/"],
+  [/\.claude\/agents\//g, ".opencode/agents/"],
+  [/~\/\.claude\//g, "~/.config/opencode/"],
+  [/CLAUDE\.md/g, "AGENTS.md"],
+  [/\/compound-engineering:/g, "/systematic:"],
+  [/compound-engineering:/g, "systematic:"]
+];
+var CC_ONLY_SKILL_FIELDS = [
+  "model",
+  "allowed-tools",
+  "allowedTools",
+  "disable-model-invocation",
+  "disableModelInvocation",
+  "user-invocable",
+  "userInvocable",
+  "context",
+  "agent"
+];
+var CC_ONLY_COMMAND_FIELDS = ["argument-hint", "argumentHint"];
+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 transformBody(body) {
+  let result = body;
+  for (const [pattern, replacement] of TOOL_MAPPINGS) {
+    result = result.replace(pattern, replacement);
+  }
+  for (const [pattern, replacement] of PATH_REPLACEMENTS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+function removeFields(data, fieldsToRemove) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (!fieldsToRemove.includes(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function transformSkillFrontmatter(data) {
+  return removeFields(data, CC_ONLY_SKILL_FIELDS);
+}
+function transformCommandFrontmatter(data) {
+  const cleaned = removeFields(data, CC_ONLY_COMMAND_FIELDS);
+  if (typeof cleaned.model === "string" && cleaned.model !== "inherit") {
+    cleaned.model = normalizeModel(cleaned.model);
+  } else if (cleaned.model === "inherit") {
+    delete cleaned.model;
+  }
+  return cleaned;
+}
+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, hadFrontmatter } = parseFrontmatter(content);
+  if (!hadFrontmatter) {
+    return options.skipBodyTransform ? content : transformBody(content);
+  }
+  const shouldTransformBody = !options.skipBodyTransform;
+  const transformedBody = shouldTransformBody ? transformBody(body) : body;
+  if (type === "agent") {
+    const agentMode = options.agentMode ?? "subagent";
+    const transformedData = transformAgentFrontmatter(data, agentMode);
+    return `${formatFrontmatter(transformedData)}
+${transformedBody}`;
+  }
+  if (type === "skill") {
+    const transformedData = transformSkillFrontmatter(data);
+    return `${formatFrontmatter(transformedData)}
+${transformedBody}`;
+  }
+  if (type === "command") {
+    const transformedData = transformCommandFrontmatter(data);
+    return `${formatFrontmatter(transformedData)}
+${transformedBody}`;
+  }
+  return content;
+}
+function convertFileWithCache(filePath, type, options = {}) {
+  const fd = fs3.openSync(filePath, "r");
+  try {
+    const stats = fs3.fstatSync(fd);
+    const cacheKey = `${filePath}:${type}:${options.source ?? "bundled"}:${options.agentMode ?? "subagent"}:${options.skipBodyTransform ?? false}`;
+    const cached = cache.get(cacheKey);
+    if (cached != null && cached.mtimeMs === stats.mtimeMs) {
+      return cached.converted;
+    }
+    const content = fs3.readFileSync(fd, "utf8");
+    const converted = convertContent(content, type, options);
+    cache.set(cacheKey, { mtimeMs: stats.mtimeMs, converted });
+    return converted;
+  } finally {
+    fs3.closeSync(fd);
+  }
+}
+
+// src/lib/skills.ts
+import fs4 from "fs";
+import path3 from "path";
+function extractFrontmatter(filePath) {
+  try {
+    const content = fs4.readFileSync(filePath, "utf8");
+    const { data, parseError } = parseFrontmatter(content);
+    if (parseError) {
+      return { name: "", description: "" };
+    }
+    return {
+      name: typeof data.name === "string" ? data.name : "",
+      description: typeof data.description === "string" ? data.description : ""
+    };
+  } catch {
+    return { name: "", description: "" };
+  }
+}
+function findSkillsInDir(dir, maxDepth = 3) {
+  const skills = [];
+  const entries = walkDir(dir, {
+    maxDepth,
+    filter: (e) => e.isDirectory
+  });
+  for (const entry of entries) {
+    const skillFile = path3.join(entry.path, "SKILL.md");
+    if (fs4.existsSync(skillFile)) {
+      const { name, description } = extractFrontmatter(skillFile);
+      skills.push({
+        path: entry.path,
+        skillFile,
+        name: name || entry.name,
+        description: description || ""
+      });
+    }
+  }
+  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 { stripFrontmatter, loadConfig, getConfigPaths, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter, convertContent, convertFileWithCache, findSkillsInDir, formatSkillsXml };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode-ai/plugin';
+export declare const SystematicPlugin: Plugin;
+export default SystematicPlugin;