@fro.bot/systematic 1.0.0

package/dist/cli.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+import {
+  findAgentsInDir,
+  findCommandsInDir,
+  findSkillsInDir
+} from "./index-v8dhd5s2.js";
+
+// src/cli.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// src/lib/converter.ts
+import fs from "node:fs";
+import path from "node:path";
+function parseFrontmatter(raw) {
+  const lines = raw.split(/\r?\n/);
+  if (lines.length === 0 || lines[0].trim() !== "---") {
+    return { data: {}, body: raw };
+  }
+  let endIndex = -1;
+  for (let i = 1;i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    return { data: {}, body: raw };
+  }
+  const yamlLines = lines.slice(1, endIndex);
+  const body = lines.slice(endIndex + 1).join(`
+`);
+  const data = {};
+  for (const line of yamlLines) {
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (match) {
+      const [, key, value] = match;
+      if (value === "true")
+        data[key] = true;
+      else if (value === "false")
+        data[key] = false;
+      else if (/^\d+(\.\d+)?$/.test(value))
+        data[key] = parseFloat(value);
+      else
+        data[key] = value;
+    }
+  }
+  return { data, body };
+}
+function formatFrontmatter(data, body) {
+  const lines = [];
+  if (data.description)
+    lines.push(`description: ${data.description}`);
+  if (data.mode)
+    lines.push(`mode: ${data.mode}`);
+  if (data.model)
+    lines.push(`model: ${data.model}`);
+  if (data.temperature !== undefined)
+    lines.push(`temperature: ${data.temperature}`);
+  if (lines.length === 0)
+    return body;
+  return ["---", ...lines, "---", "", body].join(`
+`);
+}
+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 normalizeModel(model) {
+  if (model.includes("/"))
+    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 convertAgent(sourcePath, options = {}) {
+  const content = fs.readFileSync(sourcePath, "utf-8");
+  const name = path.basename(sourcePath, ".md");
+  const { data, body } = parseFrontmatter(content);
+  const existingDescription = data.description;
+  const existingModel = data.model;
+  let description = existingDescription;
+  if (!description) {
+    const firstLine = body.split(`
+`).find((l) => l.trim() && !l.startsWith("#"));
+    description = firstLine?.slice(0, 100) || `${name} agent`;
+  }
+  const frontmatter = {
+    description,
+    mode: "subagent",
+    temperature: inferTemperature(name, description)
+  };
+  if (existingModel && existingModel !== "inherit") {
+    frontmatter.model = normalizeModel(existingModel);
+  }
+  const converted = formatFrontmatter(frontmatter, body.trim());
+  const outputPath = options.output || sourcePath;
+  if (!options.dryRun) {
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, converted);
+  }
+  return {
+    type: "agent",
+    sourcePath,
+    outputPath,
+    converted: true,
+    files: [path.basename(outputPath)]
+  };
+}
+function convertCommand(sourcePath, options = {}) {
+  const content = fs.readFileSync(sourcePath, "utf-8");
+  const outputPath = options.output || sourcePath;
+  if (!options.dryRun) {
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, content);
+  }
+  return {
+    type: "command",
+    sourcePath,
+    outputPath,
+    converted: true,
+    files: [path.basename(outputPath)]
+  };
+}
+function convertSkill(sourcePath, options = {}) {
+  const stats = fs.statSync(sourcePath);
+  if (!stats.isDirectory()) {
+    throw new Error(`Skill source must be a directory: ${sourcePath}`);
+  }
+  const skillName = path.basename(sourcePath);
+  const outputPath = options.output || sourcePath;
+  const files = [];
+  function copyDir(src, dest) {
+    if (!options.dryRun) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        copyDir(srcPath, destPath);
+      } else {
+        files.push(path.relative(outputPath, destPath));
+        if (!options.dryRun) {
+          fs.copyFileSync(srcPath, destPath);
+        }
+      }
+    }
+  }
+  copyDir(sourcePath, outputPath);
+  return {
+    type: "skill",
+    sourcePath,
+    outputPath,
+    converted: true,
+    files
+  };
+}
+function convert(type, sourcePath, options = {}) {
+  switch (type) {
+    case "agent":
+      return convertAgent(sourcePath, options);
+    case "command":
+      return convertCommand(sourcePath, options);
+    case "skill":
+      return convertSkill(sourcePath, options);
+    default:
+      throw new Error(`Unknown type: ${type}`);
+  }
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var HELP = `
+systematic - OpenCode plugin for systematic engineering workflows
+
+Usage:
+  systematic <command> [options]
+
+Commands:
+  list [type]          List available skills, agents, or commands
+  convert <type> <source> [--output <path>] [--dry-run]
+                       Convert Claude Code content to OpenCode format
+    Types: skill, agent, command
+  config [subcommand]  Configuration management
+    show               Show configuration
+    path               Print config file locations
+
+Options:
+  --output, -o         Output path for convert command
+  --dry-run            Preview conversion without writing files
+  -h, --help           Show this help message
+  -v, --version        Show version
+
+Examples:
+  systematic list skills
+  systematic convert skill /path/to/cep/skills/agent-browser -o ./skills/agent-browser
+  systematic convert agent /path/to/agent.md --dry-run
+`;
+function getUserConfigDir() {
+  return path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".config/opencode");
+}
+function getProjectConfigDir() {
+  return path2.join(process.cwd(), ".opencode");
+}
+function listItems(type) {
+  const packageRoot = path2.resolve(import.meta.dirname, "..");
+  const bundledDir = packageRoot;
+  let finder;
+  let subdir;
+  switch (type) {
+    case "skills":
+      finder = findSkillsInDir;
+      subdir = "skills";
+      break;
+    case "agents":
+      finder = findAgentsInDir;
+      subdir = "agents";
+      break;
+    case "commands":
+      finder = findCommandsInDir;
+      subdir = "commands";
+      break;
+    default:
+      console.error(`Unknown type: ${type}. Use: skills, agents, commands`);
+      process.exit(1);
+  }
+  const items = finder(path2.join(bundledDir, subdir), "bundled");
+  if (items.length === 0) {
+    console.log(`No ${type} found.`);
+    return;
+  }
+  console.log(`Available ${type}:
+`);
+  for (const item of items.sort((a, b) => a.name.localeCompare(b.name))) {
+    console.log(`  ${item.name} (${item.sourceType})`);
+  }
+}
+function configShow() {
+  const userDir = getUserConfigDir();
+  const projectDir = getProjectConfigDir();
+  console.log(`Configuration locations:
+`);
+  console.log(`  User config:    ${path2.join(userDir, "systematic.json")}`);
+  console.log(`  Project config: ${path2.join(projectDir, "systematic.json")}`);
+  const projectConfig = path2.join(projectDir, "systematic.json");
+  if (fs2.existsSync(projectConfig)) {
+    console.log(`
+Project configuration:`);
+    console.log(fs2.readFileSync(projectConfig, "utf-8"));
+  }
+  const userConfig = path2.join(userDir, "systematic.json");
+  if (fs2.existsSync(userConfig)) {
+    console.log(`
+User configuration:`);
+    console.log(fs2.readFileSync(userConfig, "utf-8"));
+  }
+}
+function configPath() {
+  const userDir = getUserConfigDir();
+  const projectDir = getProjectConfigDir();
+  console.log("Config file paths:");
+  console.log(`  User:    ${path2.join(userDir, "systematic.json")}`);
+  console.log(`  Project: ${path2.join(projectDir, "systematic.json")}`);
+}
+function runConvert(args) {
+  const typeArg = args[1];
+  const sourceArg = args[2];
+  if (!typeArg || !sourceArg) {
+    console.error("Usage: systematic convert <type> <source> [--output <path>] [--dry-run]");
+    console.error("Types: skill, agent, command");
+    process.exit(1);
+  }
+  const validTypes = ["skill", "agent", "command"];
+  if (!validTypes.includes(typeArg)) {
+    console.error(`Invalid type: ${typeArg}. Must be one of: ${validTypes.join(", ")}`);
+    process.exit(1);
+  }
+  const sourcePath = path2.resolve(sourceArg);
+  if (!fs2.existsSync(sourcePath)) {
+    console.error(`Source not found: ${sourcePath}`);
+    process.exit(1);
+  }
+  const outputIndex = args.findIndex((a) => a === "--output" || a === "-o");
+  const outputPath = outputIndex !== -1 ? path2.resolve(args[outputIndex + 1]) : undefined;
+  const dryRun = args.includes("--dry-run");
+  try {
+    const result = convert(typeArg, sourcePath, { output: outputPath, dryRun });
+    if (dryRun) {
+      console.log(`[DRY RUN] Would convert ${result.type}:`);
+    } else {
+      console.log(`Converted ${result.type}:`);
+    }
+    console.log(`  Source: ${result.sourcePath}`);
+    console.log(`  Output: ${result.outputPath}`);
+    console.log("  Files:");
+    for (const file of result.files) {
+      console.log(`    - ${file}`);
+    }
+  } catch (err) {
+    console.error(`Conversion failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+var args = process.argv.slice(2);
+var command = args[0];
+switch (command) {
+  case "list":
+    listItems(args[1] || "skills");
+    break;
+  case "convert":
+    runConvert(args);
+    break;
+  case "config":
+    switch (args[1]) {
+      case "show":
+      case undefined:
+        configShow();
+        break;
+      case "path":
+        configPath();
+        break;
+      default:
+        console.error(`Unknown config subcommand: ${args[1]}`);
+        console.log("Available: show, path");
+        process.exit(1);
+    }
+    break;
+  case "version":
+  case "--version":
+  case "-v":
+    console.log(`systematic v${VERSION}`);
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+  case undefined:
+    console.log(HELP);
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.log(HELP);
+    process.exit(1);
+}

package/dist/index-v8dhd5s2.js

@@ -0,0 +1,194 @@
+// src/lib/skills-core.ts
+import fs from "node:fs";
+import path from "node:path";
+function extractFrontmatter(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split(`
+`);
+    let inFrontmatter = false;
+    let name = "";
+    let description = "";
+    for (const line of lines) {
+      if (line.trim() === "---") {
+        if (inFrontmatter)
+          break;
+        inFrontmatter = true;
+        continue;
+      }
+      if (inFrontmatter) {
+        const match = line.match(/^(\w+):\s*(.*)$/);
+        if (match) {
+          const [, key, value] = match;
+          if (key === "name")
+            name = value.trim();
+          if (key === "description")
+            description = value.trim();
+        }
+      }
+    }
+    return { name, description };
+  } catch {
+    return { name: "", description: "" };
+  }
+}
+function stripFrontmatter(content) {
+  const lines = content.split(`
+`);
+  let inFrontmatter = false;
+  let frontmatterEnded = false;
+  const contentLines = [];
+  for (const line of lines) {
+    if (line.trim() === "---") {
+      if (inFrontmatter) {
+        frontmatterEnded = true;
+        continue;
+      }
+      inFrontmatter = true;
+      continue;
+    }
+    if (frontmatterEnded || !inFrontmatter) {
+      contentLines.push(line);
+    }
+  }
+  return contentLines.join(`
+`).trim();
+}
+function findSkillsInDir(dir, sourceType, maxDepth = 3) {
+  const skills = [];
+  if (!fs.existsSync(dir))
+    return skills;
+  function recurse(currentDir, depth) {
+    if (depth > maxDepth)
+      return;
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        const skillFile = path.join(fullPath, "SKILL.md");
+        if (fs.existsSync(skillFile)) {
+          const { name, description } = extractFrontmatter(skillFile);
+          skills.push({
+            path: fullPath,
+            skillFile,
+            name: name || entry.name,
+            description: description || "",
+            sourceType
+          });
+        }
+        recurse(fullPath, depth + 1);
+      }
+    }
+  }
+  recurse(dir, 0);
+  return skills;
+}
+function findAgentsInDir(dir, sourceType, maxDepth = 2) {
+  const agents = [];
+  if (!fs.existsSync(dir))
+    return agents;
+  function recurse(currentDir, depth, category) {
+    if (depth > maxDepth)
+      return;
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        recurse(fullPath, depth + 1, entry.name);
+      } else if (entry.name.endsWith(".md")) {
+        agents.push({
+          name: entry.name.replace(/\.md$/, ""),
+          file: fullPath,
+          sourceType,
+          category
+        });
+      }
+    }
+  }
+  recurse(dir, 0);
+  return agents;
+}
+function findCommandsInDir(dir, sourceType, maxDepth = 2) {
+  const commands = [];
+  if (!fs.existsSync(dir))
+    return commands;
+  function recurse(currentDir, depth, category) {
+    if (depth > maxDepth)
+      return;
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        recurse(fullPath, depth + 1, entry.name);
+      } else if (entry.name.endsWith(".md")) {
+        const baseName = entry.name.replace(/\.md$/, "");
+        const commandName = category ? `/${category}:${baseName}` : `/${baseName}`;
+        commands.push({
+          name: commandName,
+          file: fullPath,
+          sourceType,
+          category
+        });
+      }
+    }
+  }
+  recurse(dir, 0);
+  return commands;
+}
+function extractAgentFrontmatter(content) {
+  const lines = content.split(`
+`);
+  let inFrontmatter = false;
+  let name = "";
+  let description = "";
+  for (const line of lines) {
+    if (line.trim() === "---") {
+      if (inFrontmatter)
+        break;
+      inFrontmatter = true;
+      continue;
+    }
+    if (inFrontmatter) {
+      const match = line.match(/^(\w+(?:-\w+)*):\s*(.*)$/);
+      if (match) {
+        const [, key, value] = match;
+        if (key === "name")
+          name = value.trim();
+        if (key === "description")
+          description = value.trim();
+      }
+    }
+  }
+  return { name, description, prompt: stripFrontmatter(content) };
+}
+function extractCommandFrontmatter(content) {
+  const lines = content.split(`
+`);
+  let inFrontmatter = false;
+  let name = "";
+  let description = "";
+  let argumentHint = "";
+  for (const line of lines) {
+    if (line.trim() === "---") {
+      if (inFrontmatter)
+        break;
+      inFrontmatter = true;
+      continue;
+    }
+    if (inFrontmatter) {
+      const match = line.match(/^(\w+(?:-\w+)*):\s*(.*)$/);
+      if (match) {
+        const [, key, value] = match;
+        if (key === "name")
+          name = value.trim();
+        if (key === "description")
+          description = value.trim();
+        if (key === "argument-hint")
+          argumentHint = value.trim().replace(/^["']|["']$/g, "");
+      }
+    }
+  }
+  return { name, description, argumentHint };
+}
+
+export { stripFrontmatter, findSkillsInDir, findAgentsInDir, findCommandsInDir, extractAgentFrontmatter, extractCommandFrontmatter };