@moskala/oneagent-core 0.4.0 → 0.4.2

package/dist/index.js

@@ -0,0 +1,857 @@
+// src/constants.ts
+var ONEAGENT_DIR = ".oneagent";
+// src/agents.ts
+var AGENT_DEFINITIONS = [
+  {
+    target: "claude",
+    displayName: "Claude Code",
+    hint: "CLAUDE.md + .claude/rules/",
+    detectIndicators: ["CLAUDE.md", ".claude"],
+    mainFile: "CLAUDE.md",
+    rulesDir: ".claude/rules",
+    skillsDir: ".claude/skills",
+    commandsDir: ".claude/commands"
+  },
+  {
+    target: "cursor",
+    displayName: "Cursor",
+    hint: "AGENTS.md + .cursor/rules/",
+    detectIndicators: [".cursor", ".cursorrules"],
+    mainFile: "AGENTS.md",
+    rulesDir: ".cursor/rules",
+    skillsDir: ".cursor/skills",
+    deprecatedFiles: [".cursorrules"],
+    commandsDir: ".cursor/commands"
+  },
+  {
+    target: "windsurf",
+    displayName: "Windsurf",
+    hint: "AGENTS.md + .windsurf/rules/",
+    detectIndicators: [".windsurf", ".windsurfrules"],
+    mainFile: "AGENTS.md",
+    rulesDir: ".windsurf/rules",
+    skillsDir: ".windsurf/skills",
+    deprecatedFiles: [".windsurfrules"]
+  },
+  {
+    target: "opencode",
+    displayName: "OpenCode",
+    hint: "AGENTS.md + .opencode/",
+    detectIndicators: ["opencode.json", ".opencode"],
+    mainFile: "AGENTS.md",
+    rulesDir: ".opencode/rules",
+    skillsDir: ".opencode/skills",
+    commandsDir: ".opencode/commands"
+  },
+  {
+    target: "copilot",
+    displayName: "GitHub Copilot",
+    hint: ".github/instructions/*.instructions.md",
+    detectIndicators: [".github/copilot-instructions.md", ".github/instructions"],
+    mainFile: ".github/copilot-instructions.md",
+    skillsDir: ".github/skills"
+  }
+];
+function getAgentDef(target) {
+  return AGENT_DEFINITIONS.find((d) => d.target === target);
+}
+// src/config.ts
+import { parse, stringify } from "yaml";
+import path from "path";
+import fs from "fs/promises";
+var CONFIG_REL = `${ONEAGENT_DIR}/config.yml`;
+var ALL_AGENT_TARGETS = ["claude", "cursor", "windsurf", "opencode", "copilot"];
+function activeTargets(config) {
+  return ALL_AGENT_TARGETS.filter((t) => config.targets[t]);
+}
+function makeTargets(...enabled) {
+  return Object.fromEntries(ALL_AGENT_TARGETS.map((t) => [t, enabled.includes(t)]));
+}
+async function configExists(root) {
+  return fs.access(path.join(root, CONFIG_REL)).then(() => true, () => false);
+}
+async function readConfig(root) {
+  const content = await fs.readFile(path.join(root, CONFIG_REL), "utf-8");
+  return parse(content);
+}
+async function writeConfig(root, config) {
+  const filePath = path.join(root, CONFIG_REL);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, stringify(config));
+}
+// src/detect.ts
+import path2 from "path";
+import fs2 from "fs/promises";
+var AGENT_FILES = [
+  "CLAUDE.md",
+  "AGENTS.md",
+  ".cursorrules",
+  ".windsurfrules",
+  ".github/copilot-instructions.md"
+];
+async function readDetectedFile(root, rel) {
+  const absolutePath = path2.join(root, rel);
+  try {
+    const stat = await fs2.lstat(absolutePath);
+    if (stat.isSymbolicLink()) {
+      const linkTarget = await fs2.readlink(absolutePath);
+      const resolved = path2.resolve(path2.dirname(absolutePath), linkTarget);
+      if (resolved.startsWith(path2.join(root, ONEAGENT_DIR)))
+        return null;
+    }
+    const content = await fs2.readFile(absolutePath, "utf-8");
+    return {
+      relativePath: rel,
+      absolutePath,
+      sizeBytes: stat.size,
+      modifiedAt: stat.mtime,
+      content
+    };
+  } catch {
+    return null;
+  }
+}
+async function detectExistingFiles(root) {
+  const results = await Promise.all(AGENT_FILES.map((rel) => readDetectedFile(root, rel)));
+  return results.filter((f) => f !== null);
+}
+function filesHaveSameContent(files) {
+  if (files.length <= 1)
+    return true;
+  const first = files[0].content;
+  return files.every((f) => f.content === first);
+}
+var DEPRECATED_FILES = AGENT_DEFINITIONS.flatMap((d) => d.deprecatedFiles ?? []);
+async function removeDeprecatedFiles(root) {
+  for (const rel of DEPRECATED_FILES) {
+    const absPath = path2.join(root, rel);
+    try {
+      const stat = await fs2.lstat(absPath);
+      if (!stat.isSymbolicLink())
+        await fs2.unlink(absPath);
+    } catch {}
+  }
+}
+// src/rules.ts
+import path3 from "path";
+import fs3 from "fs/promises";
+async function readRules(root) {
+  const rulesDir = path3.join(root, ONEAGENT_DIR, "rules");
+  try {
+    const files = await fs3.readdir(rulesDir);
+    return files.filter((f) => f.endsWith(".md")).map((f) => ({ name: path3.basename(f, ".md"), path: path3.join(rulesDir, f) })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}
+// src/commands.ts
+import path4 from "path";
+import fs4 from "fs/promises";
+async function readCommands(root) {
+  const commandsDir = path4.join(root, ONEAGENT_DIR, "commands");
+  try {
+    const files = await fs4.readdir(commandsDir);
+    return files.filter((f) => f.endsWith(".md")).map((f) => ({ name: path4.basename(f, ".md"), path: path4.join(commandsDir, f) })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}
+// src/skills.ts
+import path5 from "path";
+import fs5 from "fs/promises";
+var VALID_MODES = ["ask", "edit", "agent"];
+function parseSkillFrontmatter(raw) {
+  const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+  if (!match)
+    return { description: "", mode: "agent", content: raw };
+  const frontmatter = match[1] ?? "";
+  const content = match[2] ?? "";
+  const descMatch = frontmatter.match(/description:\s*["']?([^"'\n]+)["']?/);
+  const description = descMatch?.[1]?.trim() ?? "";
+  const modeMatch = frontmatter.match(/mode:\s*["']?([^"'\n]+)["']?/);
+  const modeRaw = modeMatch?.[1]?.trim() ?? "agent";
+  const mode = VALID_MODES.includes(modeRaw) ? modeRaw : "agent";
+  return { description, mode, content };
+}
+async function readSkillFile(filePath) {
+  const raw = await fs5.readFile(filePath, "utf-8");
+  const { description, mode, content } = parseSkillFrontmatter(raw);
+  return { name: path5.basename(filePath, ".md"), path: filePath, description, mode, content };
+}
+async function readSkills(root) {
+  const skillsDir = path5.join(root, ONEAGENT_DIR, "skills");
+  try {
+    const files = await fs5.readdir(skillsDir);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+    const skills = await Promise.all(mdFiles.map((f) => readSkillFile(path5.join(skillsDir, f))));
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}
+// src/symlinks.ts
+import path6 from "path";
+import fs6 from "fs/promises";
+async function ensureDir(dirPath) {
+  await fs6.mkdir(dirPath, { recursive: true });
+}
+async function createSymlink(symlinkPath, target) {
+  await ensureDir(path6.dirname(symlinkPath));
+  try {
+    const stat = await fs6.lstat(symlinkPath);
+    if (stat.isSymbolicLink() && await fs6.readlink(symlinkPath) === target)
+      return;
+  } catch {}
+  for (let attempt = 0;attempt < 3; attempt++) {
+    await fs6.rm(symlinkPath, { recursive: true, force: true });
+    try {
+      await fs6.symlink(target, symlinkPath);
+      return;
+    } catch (err) {
+      if (err.code !== "EEXIST" || attempt === 2)
+        throw err;
+    }
+  }
+}
+function relativeTarget(symlinkPath, targetAbsPath) {
+  return path6.relative(path6.dirname(symlinkPath), targetAbsPath);
+}
+function buildMainSymlinks(root, targets) {
+  const instructionsAbs = path6.join(root, ONEAGENT_DIR, "instructions.md");
+  const seen = new Map;
+  for (const target of targets) {
+    const def = AGENT_DEFINITIONS.find((d) => d.target === target);
+    const symlinkPath = path6.join(root, def.mainFile);
+    if (!seen.has(symlinkPath)) {
+      seen.set(symlinkPath, {
+        symlinkPath,
+        target: relativeTarget(symlinkPath, instructionsAbs),
+        label: path6.relative(root, symlinkPath)
+      });
+    }
+  }
+  return Array.from(seen.values());
+}
+function buildRulesSymlinks(root, targets) {
+  const targetAbs = path6.join(root, ONEAGENT_DIR, "rules");
+  return AGENT_DEFINITIONS.filter((d) => targets.includes(d.target) && d.rulesDir).map((d) => {
+    const symlinkPath = path6.join(root, d.rulesDir);
+    return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d.rulesDir };
+  });
+}
+function buildSkillSymlinks(root, targets) {
+  const targetAbs = path6.join(root, ONEAGENT_DIR, "skills");
+  return AGENT_DEFINITIONS.filter((d) => targets.includes(d.target) && d.skillsDir).map((d) => {
+    const symlinkPath = path6.join(root, d.skillsDir);
+    return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d.skillsDir };
+  });
+}
+function buildCommandSymlinks(root, targets) {
+  const targetAbs = path6.join(root, ONEAGENT_DIR, "commands");
+  return AGENT_DEFINITIONS.filter((d) => targets.includes(d.target) && d.commandsDir).map((d) => {
+    const symlinkPath = path6.join(root, d.commandsDir);
+    return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d.commandsDir };
+  });
+}
+function buildAgentsDirSymlinks(root) {
+  const symlinkPath = path6.join(root, ".agents/skills");
+  const targetAbs = path6.join(root, ONEAGENT_DIR, "skills");
+  return [{ symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: ".agents/skills" }];
+}
+async function migrateFilesFromDir(srcDir, destDir, root) {
+  await fs6.mkdir(destDir, { recursive: true });
+  let entries;
+  try {
+    entries = await fs6.readdir(srcDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const srcFile = path6.join(srcDir, entry.name);
+    const fileStat = await fs6.lstat(srcFile);
+    if (fileStat.isSymbolicLink())
+      continue;
+    if (fileStat.isDirectory()) {
+      const destSub = path6.join(destDir, entry.name);
+      try {
+        await fs6.access(destSub);
+      } catch {
+        await fs6.mkdir(destDir, { recursive: true });
+        await fs6.rename(srcFile, destSub);
+      }
+      continue;
+    }
+    if (!fileStat.isFile())
+      continue;
+    const destFile = path6.join(destDir, entry.name);
+    let destExists = false;
+    try {
+      await fs6.access(destFile);
+      destExists = true;
+    } catch {}
+    if (destExists) {
+      const [srcContent, destContent] = await Promise.all([
+        fs6.readFile(srcFile, "utf-8"),
+        fs6.readFile(destFile, "utf-8")
+      ]);
+      if (srcContent !== destContent) {
+        const backupDir = path6.join(root, ONEAGENT_DIR, "backup");
+        await fs6.mkdir(backupDir, { recursive: true });
+        const safeName = path6.relative(root, srcFile).replace(/\//g, "_");
+        await fs6.writeFile(path6.join(backupDir, safeName), srcContent);
+      }
+      await fs6.unlink(srcFile);
+    } else {
+      await fs6.rename(srcFile, destFile);
+    }
+  }
+}
+async function migrateAndRemoveDir(src, dest, root) {
+  let stat;
+  try {
+    stat = await fs6.lstat(src);
+  } catch {
+    return;
+  }
+  if (stat.isSymbolicLink() || !stat.isDirectory())
+    return;
+  await migrateFilesFromDir(src, dest, root);
+  await fs6.rm(src, { recursive: true, force: true });
+}
+async function migrateRuleAndSkillFiles(root) {
+  const destRules = path6.join(root, ONEAGENT_DIR, "rules");
+  const destSkills = path6.join(root, ONEAGENT_DIR, "skills");
+  const destCommands = path6.join(root, ONEAGENT_DIR, "commands");
+  for (const def of AGENT_DEFINITIONS) {
+    if (def.rulesDir)
+      await migrateAndRemoveDir(path6.join(root, def.rulesDir), destRules, root);
+  }
+  for (const def of AGENT_DEFINITIONS) {
+    if (def.skillsDir)
+      await migrateAndRemoveDir(path6.join(root, def.skillsDir), destSkills, root);
+  }
+  await migrateAndRemoveDir(path6.join(root, ".agents/skills"), destSkills, root);
+  for (const def of AGENT_DEFINITIONS) {
+    if (def.commandsDir)
+      await migrateAndRemoveDir(path6.join(root, def.commandsDir), destCommands, root);
+  }
+}
+async function backupDirRecursive(srcDir, backupDir, prefix) {
+  let entries;
+  try {
+    entries = await fs6.readdir(srcDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const srcPath = path6.join(srcDir, entry.name);
+    const lstat = await fs6.lstat(srcPath);
+    if (lstat.isSymbolicLink())
+      continue;
+    if (lstat.isDirectory()) {
+      await backupDirRecursive(srcPath, backupDir, `${prefix}_${entry.name}`);
+    } else if (lstat.isFile()) {
+      await fs6.mkdir(backupDir, { recursive: true });
+      await fs6.copyFile(srcPath, path6.join(backupDir, `${prefix}_${entry.name}`));
+    }
+  }
+}
+async function cleanupAgentDir(root, target) {
+  const def = AGENT_DEFINITIONS.find((d) => d.target === target);
+  const backupDir = path6.join(root, ONEAGENT_DIR, "backup");
+  const agentDir = [def.rulesDir, def.skillsDir, def.commandsDir].filter(Boolean).map((d) => d.split("/")[0]).find((d) => d !== ".github");
+  if (agentDir) {
+    const agentDirAbs = path6.join(root, agentDir);
+    let stat;
+    try {
+      stat = await fs6.lstat(agentDirAbs);
+    } catch {}
+    if (stat && stat.isDirectory() && !stat.isSymbolicLink()) {
+      await backupDirRecursive(agentDirAbs, backupDir, agentDir);
+      await fs6.rm(agentDirAbs, { recursive: true, force: true });
+    }
+  }
+  if (target === "opencode") {
+    const opPath = path6.join(root, "opencode.json");
+    try {
+      const content = await fs6.readFile(opPath, "utf-8");
+      await fs6.mkdir(backupDir, { recursive: true });
+      await fs6.writeFile(path6.join(backupDir, "opencode.json"), content);
+    } catch {}
+    try {
+      await fs6.unlink(opPath);
+    } catch {}
+  }
+}
+async function createAllSymlinks(entries) {
+  const deduped = new Map;
+  for (const e of entries)
+    deduped.set(e.symlinkPath, e);
+  for (const e of deduped.values()) {
+    await createSymlink(e.symlinkPath, e.target);
+  }
+}
+async function checkSymlink(entry) {
+  try {
+    const stat = await fs6.lstat(entry.symlinkPath);
+    if (!stat.isSymbolicLink()) {
+      return { ...entry, exists: true, valid: false };
+    }
+    const linkTarget = await fs6.readlink(entry.symlinkPath);
+    return { ...entry, exists: true, valid: linkTarget === entry.target };
+  } catch {
+    return { ...entry, exists: false, valid: false };
+  }
+}
+// src/copilot.ts
+import path7 from "path";
+import fs7 from "fs/promises";
+function copilotFilePath(root, ruleName) {
+  return path7.join(root, ".github/instructions", `${ruleName}.instructions.md`);
+}
+async function generateCopilotRule(root, rule) {
+  const destPath = copilotFilePath(root, rule.name);
+  await fs7.mkdir(path7.dirname(destPath), { recursive: true });
+  await fs7.copyFile(rule.path, destPath);
+}
+async function generateCopilotRules(root, rules) {
+  await Promise.all(rules.map((rule) => generateCopilotRule(root, rule)));
+}
+function buildCopilotPromptContent(skill) {
+  const lines = ["---", `mode: "${skill.mode}"`];
+  if (skill.description)
+    lines.push(`description: "${skill.description}"`);
+  lines.push("---", skill.content);
+  return lines.join(`
+`);
+}
+function copilotPromptFilePath(root, skillName) {
+  return path7.join(root, ".github/prompts", `${skillName}.prompt.md`);
+}
+async function generateCopilotSkill(root, skill) {
+  const filePath = copilotPromptFilePath(root, skill.name);
+  await fs7.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs7.writeFile(filePath, buildCopilotPromptContent(skill));
+}
+async function generateCopilotSkills(root, skills) {
+  await Promise.all(skills.map((skill) => generateCopilotSkill(root, skill)));
+}
+// src/opencode.ts
+import path8 from "path";
+import fs8 from "fs/promises";
+async function readOpencode(root) {
+  try {
+    const content = await fs8.readFile(path8.join(root, "opencode.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function buildOpencodeConfig(existing) {
+  return {
+    ...existing,
+    instructions: `${ONEAGENT_DIR}/instructions.md`
+  };
+}
+async function addOpenCodePlugin(root, id) {
+  const filePath = path8.join(root, "opencode.json");
+  let existing;
+  try {
+    existing = JSON.parse(await fs8.readFile(filePath, "utf-8"));
+  } catch {
+    return;
+  }
+  const current = Array.isArray(existing.plugin) ? existing.plugin : [];
+  if (current.includes(id))
+    return;
+  existing.plugin = [...current, id];
+  await fs8.writeFile(filePath, JSON.stringify(existing, null, 2) + `
+`);
+}
+async function writeOpencode(root, _rules) {
+  const existing = await readOpencode(root);
+  const config = buildOpencodeConfig(existing);
+  await fs8.writeFile(path8.join(root, "opencode.json"), JSON.stringify(config, null, 2) + `
+`);
+}
+// src/generate.ts
+import path9 from "path";
+import fs9 from "fs/promises";
+async function detectGenerateCollisions(root, config) {
+  const [rules, skills] = await Promise.all([readRules(root), readSkills(root)]);
+  const targets = activeTargets(config);
+  const mainEntries = buildMainSymlinks(root, targets);
+  const ruleSkillEntries = [
+    ...buildRulesSymlinks(root, targets),
+    ...buildSkillSymlinks(root, targets),
+    ...buildCommandSymlinks(root, targets)
+  ];
+  const [mainCollisions, ruleSkillSymlinkCollisions] = await Promise.all([
+    Promise.all(mainEntries.map((entry) => readDetectedFile(root, path9.relative(root, entry.symlinkPath)))).then((files) => files.filter((f) => f !== null)),
+    Promise.all(ruleSkillEntries.map((entry) => readDetectedFile(root, path9.relative(root, entry.symlinkPath)))).then((files) => files.filter((f) => f !== null))
+  ]);
+  const copilotCollisions = [];
+  if (targets.includes("copilot")) {
+    const checks = await Promise.all([
+      ...rules.map(async (rule) => {
+        const filePath = copilotFilePath(root, rule.name);
+        try {
+          const [source, dest] = await Promise.all([
+            fs9.readFile(rule.path, "utf-8"),
+            fs9.readFile(filePath, "utf-8")
+          ]);
+          if (source === dest)
+            return null;
+          const stat = await fs9.lstat(filePath);
+          return { relativePath: path9.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content: dest };
+        } catch {
+          return null;
+        }
+      }),
+      ...skills.map(async (skill) => {
+        const filePath = copilotPromptFilePath(root, skill.name);
+        try {
+          const content = await fs9.readFile(filePath, "utf-8");
+          if (content === buildCopilotPromptContent(skill))
+            return null;
+          const stat = await fs9.lstat(filePath);
+          return { relativePath: path9.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content };
+        } catch {
+          return null;
+        }
+      })
+    ]);
+    copilotCollisions.push(...checks.filter((c) => c !== null));
+  }
+  return {
+    mainFiles: mainCollisions,
+    ruleSkillFiles: [...ruleSkillSymlinkCollisions, ...copilotCollisions]
+  };
+}
+async function generate(root, config) {
+  const [rules, skills] = await Promise.all([readRules(root), readSkills(root)]);
+  const targets = activeTargets(config);
+  await migrateRuleAndSkillFiles(root);
+  const mainSymlinks = buildMainSymlinks(root, targets);
+  const rulesSymlinks = buildRulesSymlinks(root, targets);
+  const skillSymlinks = await buildSkillSymlinks(root, targets);
+  const commandSymlinks = buildCommandSymlinks(root, targets);
+  await createAllSymlinks([...mainSymlinks, ...rulesSymlinks, ...skillSymlinks, ...commandSymlinks, ...buildAgentsDirSymlinks(root)]);
+  if (targets.includes("copilot")) {
+    await Promise.all([generateCopilotRules(root, rules), generateCopilotSkills(root, skills)]);
+  }
+  if (targets.includes("opencode")) {
+    await writeOpencode(root, rules);
+  }
+}
+// src/status.ts
+import fs10 from "fs/promises";
+async function checkGeneratedFile(root, rule) {
+  const filePath = copilotFilePath(root, rule.name);
+  try {
+    const [source, dest] = await Promise.all([
+      fs10.readFile(rule.path, "utf-8"),
+      fs10.readFile(filePath, "utf-8")
+    ]);
+    return { path: filePath, exists: true, upToDate: source === dest };
+  } catch {
+    return { path: filePath, exists: false, upToDate: false };
+  }
+}
+async function checkOpencodeStatus(root, _rules) {
+  const existing = await readOpencode(root);
+  if (!existing)
+    return { exists: false, valid: false };
+  return { exists: true, valid: existing["instructions"] === `${ONEAGENT_DIR}/instructions.md` };
+}
+async function checkCopilotPrompt(root, skill) {
+  const filePath = copilotPromptFilePath(root, skill.name);
+  const expected = buildCopilotPromptContent(skill);
+  try {
+    const content = await fs10.readFile(filePath, "utf-8");
+    return { path: filePath, exists: true, upToDate: content === expected };
+  } catch {
+    return { path: filePath, exists: false, upToDate: false };
+  }
+}
+async function checkStatus(root, config) {
+  const [rules, skills] = await Promise.all([readRules(root), readSkills(root)]);
+  const targets = activeTargets(config);
+  const allEntries = [
+    ...buildMainSymlinks(root, targets),
+    ...buildRulesSymlinks(root, targets),
+    ...buildSkillSymlinks(root, targets),
+    ...buildCommandSymlinks(root, targets),
+    ...buildAgentsDirSymlinks(root)
+  ];
+  const symlinks = await Promise.all(allEntries.map(checkSymlink));
+  const generatedFiles = targets.includes("copilot") ? await Promise.all([
+    ...rules.map((rule) => checkGeneratedFile(root, rule)),
+    ...skills.map((skill) => checkCopilotPrompt(root, skill))
+  ]) : [];
+  const opencode = await checkOpencodeStatus(root, rules);
+  return { symlinks, generatedFiles, opencode };
+}
+// src/apply-template.ts
+import path10 from "path";
+import fs11 from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function parseTemplateYaml(yamlText, fallbackName = "custom") {
+  const nameMatch = yamlText.match(/^name:\s*(.+)$/m);
+  const name = nameMatch?.[1]?.trim() ?? fallbackName;
+  const descMatch = yamlText.match(/^description:\s*(.+)$/m);
+  const description = descMatch?.[1]?.trim() ?? "";
+  const extendsMatch = yamlText.match(/^extends:\s*(.+)$/m);
+  const extendsValue = extendsMatch?.[1]?.trim();
+  const skills = parseSkillsFromYaml(yamlText);
+  const plugins = parsePluginsFromYaml(yamlText);
+  return { name, description, skills, plugins, ...extendsValue ? { extends: extendsValue } : {} };
+}
+function parseSkillsFromYaml(yamlText) {
+  const skills = [];
+  const section = yamlText.match(/^skills:\s*\n((?:(?:  -.+|\s{4}.+)\n?)*)/m);
+  if (!section)
+    return skills;
+  const block = section[1];
+  const entries = block.split(/\n(?=  -)/);
+  for (const entry of entries) {
+    const repoMatch = entry.match(/repo:\s*(\S+)/);
+    const skillMatch = entry.match(/skill:\s*(\S+)/);
+    if (repoMatch && skillMatch) {
+      skills.push({ repo: repoMatch[1].trim(), skill: skillMatch[1].trim() });
+    }
+  }
+  return skills;
+}
+function parsePluginsFromYaml(yamlText) {
+  const plugins = [];
+  const section = yamlText.match(/^plugins:\s*\n((?:(?:  -.+|\s{4}.+)\n?)*)/m);
+  if (!section)
+    return plugins;
+  const block = section[1];
+  const entries = block.split(/\n(?=  -)/);
+  for (const entry of entries) {
+    const targetMatch = entry.match(/target:\s*(\S+)/);
+    const idMatch = entry.match(/id:\s*(.+)/);
+    if (targetMatch && idMatch) {
+      plugins.push({
+        target: targetMatch[1].trim(),
+        id: idMatch[1].trim()
+      });
+    }
+  }
+  return plugins;
+}
+async function resolveExtends(child, resolveBuiltin) {
+  if (!child.extends)
+    return child;
+  let parent;
+  if (child.extends.startsWith("https://")) {
+    parent = await fetchTemplateFromGitHub(child.extends);
+  } else if (resolveBuiltin) {
+    const resolved = await resolveBuiltin(child.extends);
+    if (!resolved)
+      throw new Error(`Unknown builtin template: "${child.extends}"`);
+    parent = resolved;
+  } else {
+    throw new Error(`Cannot resolve extends: "${child.extends}"`);
+  }
+  return {
+    name: child.name,
+    description: child.description,
+    instructions: child.instructions,
+    skills: [...parent.skills, ...child.skills],
+    plugins: [...parent.plugins, ...child.plugins],
+    rules: [...parent.rules, ...child.rules]
+  };
+}
+async function applyTemplateFiles(root, template) {
+  const oneagentDir = path10.join(root, ONEAGENT_DIR);
+  await fs11.mkdir(path10.join(oneagentDir, "rules"), { recursive: true });
+  await fs11.mkdir(path10.join(oneagentDir, "skills"), { recursive: true });
+  await fs11.writeFile(path10.join(oneagentDir, "instructions.md"), template.instructions);
+  for (const rule of template.rules) {
+    await fs11.writeFile(path10.join(oneagentDir, "rules", `${rule.name}.md`), rule.content);
+  }
+}
+async function installTemplateSkills(root, template) {
+  const installed = [];
+  const failed = [];
+  for (const entry of template.skills) {
+    try {
+      await execFileAsync("npx", ["skills", "add", entry.repo, "--skill", entry.skill, "--agent", "universal", "--yes"], { cwd: root });
+      installed.push(entry);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      failed.push({ entry, reason });
+    }
+  }
+  return { installed, failed };
+}
+var BUILTIN_SKILL_REPO = "https://github.com/moskalakamil/oneagent";
+var BUILTIN_SKILL_NAME = "oneagent";
+async function installBuiltinSkill(root) {
+  try {
+    await execFileAsync("npx", ["skills", "add", BUILTIN_SKILL_REPO, "--skill", BUILTIN_SKILL_NAME, "--agent", "universal", "--yes"], { cwd: root });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installTemplatePlugins(root, template, activeTargets2) {
+  const installed = [];
+  const manual = [];
+  const failed = [];
+  for (const plugin of template.plugins) {
+    if (!activeTargets2.includes(plugin.target))
+      continue;
+    try {
+      switch (plugin.target) {
+        case "claude":
+          await execFileAsync("claude", ["plugin", "install", plugin.id], { cwd: root });
+          installed.push(plugin);
+          break;
+        case "copilot":
+          await execFileAsync("copilot", ["plugin", "install", plugin.id], { cwd: root });
+          installed.push(plugin);
+          break;
+        case "opencode":
+          await addOpenCodePlugin(root, plugin.id);
+          installed.push(plugin);
+          break;
+        case "cursor":
+          manual.push(plugin);
+          break;
+        case "windsurf":
+          break;
+      }
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      failed.push({ plugin, reason });
+    }
+  }
+  return { installed, manual, failed };
+}
+async function fetchTemplateFromGitHub(url) {
+  const { owner, repo, branch, subdir } = parseGitHubUrl(url);
+  const branchExplicit = url.includes("/tree/");
+  const resolvedBranch = branchExplicit ? branch : await fetchDefaultBranch(owner, repo);
+  const rawBase = `https://raw.githubusercontent.com/${owner}/${repo}/${resolvedBranch}${subdir ? `/${subdir}` : ""}`;
+  const [yamlText, instructions] = await Promise.all([
+    fetchText(`${rawBase}/template.yml`),
+    fetchText(`${rawBase}/instructions.md`)
+  ]);
+  const parsed = parseTemplateYaml(yamlText);
+  const rules = await fetchGitHubRules(url);
+  const base = { ...parsed, instructions, rules };
+  return resolveExtends(base);
+}
+async function fetchDefaultBranch(owner, repo) {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+      headers: { Accept: "application/vnd.github.v3+json" }
+    });
+    if (!response.ok)
+      return "main";
+    const data = await response.json();
+    return data.default_branch ?? "main";
+  } catch {
+    return "main";
+  }
+}
+async function fetchText(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  }
+  return response.text();
+}
+function parseGitHubUrl(url) {
+  const match = url.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+?)(?:\/(.+))?)?(?:\/)?$/);
+  if (!match) {
+    throw new Error(`Invalid GitHub URL: "${url}". Expected format: https://github.com/owner/repo`);
+  }
+  const [, owner, repo, branch = "main", subdir = ""] = match;
+  return { owner, repo, branch, subdir };
+}
+async function fetchGitHubRules(repoUrl) {
+  const { owner, repo, branch, subdir } = parseGitHubUrl(repoUrl);
+  const rulesPath = subdir ? `${subdir}/rules` : "rules";
+  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${rulesPath}?ref=${branch}`;
+  try {
+    const response = await fetch(apiUrl, {
+      headers: { Accept: "application/vnd.github.v3+json" }
+    });
+    if (!response.ok)
+      return [];
+    const files = await response.json();
+    const mdFiles = files.filter((f) => f.name.endsWith(".md") && f.download_url);
+    const rules = await Promise.all(mdFiles.map(async (f) => {
+      const content = await fetchText(f.download_url);
+      return { name: path10.basename(f.name, ".md"), content };
+    }));
+    return rules;
+  } catch {
+    return [];
+  }
+}
+export {
+  writeOpencode,
+  writeConfig,
+  resolveExtends,
+  removeDeprecatedFiles,
+  readSkills,
+  readSkillFile,
+  readRules,
+  readOpencode,
+  readDetectedFile,
+  readConfig,
+  readCommands,
+  parseTemplateYaml,
+  parseSkillsFromYaml,
+  parseSkillFrontmatter,
+  parsePluginsFromYaml,
+  migrateRuleAndSkillFiles,
+  makeTargets,
+  installTemplateSkills,
+  installTemplatePlugins,
+  installBuiltinSkill,
+  getAgentDef,
+  generateCopilotSkills,
+  generateCopilotSkill,
+  generateCopilotRules,
+  generateCopilotRule,
+  generate,
+  filesHaveSameContent,
+  fetchTemplateFromGitHub,
+  ensureDir,
+  detectGenerateCollisions,
+  detectExistingFiles,
+  createSymlink,
+  createAllSymlinks,
+  copilotPromptFilePath,
+  copilotFilePath,
+  configExists,
+  cleanupAgentDir,
+  checkSymlink,
+  checkStatus,
+  checkOpencodeStatus,
+  checkGeneratedFile,
+  checkCopilotPrompt,
+  buildSkillSymlinks,
+  buildRulesSymlinks,
+  buildOpencodeConfig,
+  buildMainSymlinks,
+  buildCopilotPromptContent,
+  buildCommandSymlinks,
+  buildAgentsDirSymlinks,
+  applyTemplateFiles,
+  addOpenCodePlugin,
+  activeTargets,
+  ONEAGENT_DIR,
+  ALL_AGENT_TARGETS,
+  AGENT_FILES,
+  AGENT_DEFINITIONS
+};