oneagent 0.2.2 → 0.2.4

package/dist/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-#!/usr/bin/env bun
 // @bun
 import { createRequire } from "node:module";
 var __create = Object.create;
@@ -8244,6 +8243,7 @@ var init_dist4 = __esm(() => {
 
 // ../core/src/config.ts
 import path from "path";
+import fs from "fs/promises";
 function activeTargets(config) {
   return ALL_AGENT_TARGETS.filter((t) => config.targets[t]);
 }
@@ -8251,15 +8251,16 @@ function makeTargets(...enabled) {
   return Object.fromEntries(ALL_AGENT_TARGETS.map((t) => [t, enabled.includes(t)]));
 }
 async function configExists(root) {
-  return Bun.file(path.join(root, CONFIG_REL)).exists();
+  return fs.access(path.join(root, CONFIG_REL)).then(() => true, () => false);
 }
 async function readConfig(root) {
-  const content = await Bun.file(path.join(root, CONFIG_REL)).text();
+  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 Bun.write(filePath, $stringify(config));
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, $stringify(config));
 }
 var CONFIG_REL = ".oneagent/config.yml", ALL_AGENT_TARGETS;
 var init_config = __esm(() => {
@@ -8269,18 +8270,18 @@ var init_config = __esm(() => {
 
 // ../core/src/detect.ts
 import path2 from "path";
-import fs from "fs/promises";
+import fs2 from "fs/promises";
 async function readDetectedFile(root, rel) {
   const absolutePath = path2.join(root, rel);
   try {
-    const stat = await fs.lstat(absolutePath);
+    const stat = await fs2.lstat(absolutePath);
     if (stat.isSymbolicLink()) {
-      const linkTarget = await fs.readlink(absolutePath);
+      const linkTarget = await fs2.readlink(absolutePath);
       const resolved = path2.resolve(path2.dirname(absolutePath), linkTarget);
       if (resolved.startsWith(path2.join(root, ".one")))
         return null;
     }
-    const content = await Bun.file(absolutePath).text();
+    const content = await fs2.readFile(absolutePath, "utf-8");
     return {
       relativePath: rel,
       absolutePath,
@@ -8306,16 +8307,16 @@ async function removeDeprecatedFiles(root) {
   for (const rel of DEPRECATED_FILES) {
     const absPath = path2.join(root, rel);
     try {
-      const stat = await fs.lstat(absPath);
+      const stat = await fs2.lstat(absPath);
       if (!stat.isSymbolicLink())
-        await fs.unlink(absPath);
+        await fs2.unlink(absPath);
     } catch {}
   }
 }
 async function detectDeprecatedCommandFiles(root) {
   const commandsDir = path2.join(root, ".claude/commands");
   try {
-    const entries = await fs.readdir(commandsDir, { withFileTypes: true });
+    const entries = await fs2.readdir(commandsDir, { withFileTypes: true });
     return entries.filter((e2) => e2.isFile()).map((e2) => path2.join(".claude/commands", e2.name));
   } catch {
     return [];
@@ -8335,7 +8336,7 @@ var init_detect = __esm(() => {
 
 // ../core/src/rules.ts
 import path3 from "path";
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
   if (!match)
@@ -8347,14 +8348,14 @@ function parseFrontmatter(raw) {
   return { applyTo, content };
 }
 async function readRuleFile(filePath) {
-  const raw = await Bun.file(filePath).text();
+  const raw = await fs3.readFile(filePath, "utf-8");
   const { applyTo, content } = parseFrontmatter(raw);
   return { name: path3.basename(filePath, ".md"), path: filePath, applyTo, content };
 }
 async function readRules(root) {
   const rulesDir = path3.join(root, ".oneagent/rules");
   try {
-    const files = await fs2.readdir(rulesDir);
+    const files = await fs3.readdir(rulesDir);
     const mdFiles = files.filter((f) => f.endsWith(".md"));
     const rules = await Promise.all(mdFiles.map((f) => readRuleFile(path3.join(rulesDir, f))));
     return rules.sort((a, b) => a.name.localeCompare(b.name));
@@ -8366,7 +8367,7 @@ var init_rules = () => {};
 
 // ../core/src/skills.ts
 import path4 from "path";
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 function parseSkillFrontmatter(raw) {
   const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
   if (!match)
@@ -8381,14 +8382,14 @@ function parseSkillFrontmatter(raw) {
   return { description, mode, content };
 }
 async function readSkillFile(filePath) {
-  const raw = await Bun.file(filePath).text();
+  const raw = await fs4.readFile(filePath, "utf-8");
   const { description, mode, content } = parseSkillFrontmatter(raw);
   return { name: path4.basename(filePath, ".md"), path: filePath, description, mode, content };
 }
 async function readSkills(root) {
   const skillsDir = path4.join(root, ".oneagent/skills");
   try {
-    const files = await fs3.readdir(skillsDir);
+    const files = await fs4.readdir(skillsDir);
     const mdFiles = files.filter((f) => f.endsWith(".md"));
     const skills = await Promise.all(mdFiles.map((f) => readSkillFile(path4.join(skillsDir, f))));
     return skills.sort((a, b) => a.name.localeCompare(b.name));
@@ -8403,16 +8404,16 @@ var init_skills = __esm(() => {
 
 // ../core/src/symlinks.ts
 import path5 from "path";
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 async function ensureDir(dirPath) {
-  await fs4.mkdir(dirPath, { recursive: true });
+  await fs5.mkdir(dirPath, { recursive: true });
 }
 async function createSymlink(symlinkPath, target) {
   await ensureDir(path5.dirname(symlinkPath));
   try {
-    await fs4.unlink(symlinkPath);
+    await fs5.unlink(symlinkPath);
   } catch {}
-  await fs4.symlink(target, symlinkPath);
+  await fs5.symlink(target, symlinkPath);
 }
 function relativeTarget(symlinkPath, targetAbsPath) {
   return path5.relative(path5.dirname(symlinkPath), targetAbsPath);
@@ -8481,18 +8482,19 @@ function buildRulesSymlinks(root, targets, rules) {
   }
   return entries;
 }
-function buildSkillSymlinks(root, targets, skills) {
-  if (!targets.includes("claude"))
-    return [];
-  const commandsDir = path5.join(root, ".claude/commands");
-  return skills.map((skill) => {
-    const symlinkPath = path5.join(commandsDir, `${skill.name}.md`);
-    return {
-      symlinkPath,
-      target: relativeTarget(symlinkPath, skill.path),
-      label: path5.relative(root, symlinkPath)
-    };
-  });
+function buildSkillSymlinks(root, targets) {
+  const targetAbs = path5.join(root, ".oneagent/skills");
+  const agentDirs = {
+    claude: path5.join(root, ".claude/skills"),
+    cursor: path5.join(root, ".cursor/skills"),
+    windsurf: path5.join(root, ".windsurf/skills"),
+    copilot: path5.join(root, ".github/skills")
+  };
+  return Object.entries(agentDirs).filter(([target]) => targets.includes(target)).map(([, dir]) => ({
+    symlinkPath: dir,
+    target: relativeTarget(dir, targetAbs),
+    label: path5.relative(root, dir)
+  }));
 }
 function buildAgentsDirSymlinks(root) {
   const symlinkPath = path5.join(root, ".agents/skills");
@@ -8500,10 +8502,10 @@ function buildAgentsDirSymlinks(root) {
   return [{ symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: ".agents/skills" }];
 }
 async function migrateFilesFromDir(srcDir, destDir, root) {
-  await fs4.mkdir(destDir, { recursive: true });
+  await fs5.mkdir(destDir, { recursive: true });
   let entries;
   try {
-    entries = await fs4.readdir(srcDir, { withFileTypes: true });
+    entries = await fs5.readdir(srcDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -8514,37 +8516,37 @@ async function migrateFilesFromDir(srcDir, destDir, root) {
     const destFile = path5.join(destDir, entry.name);
     let destExists = false;
     try {
-      await fs4.access(destFile);
+      await fs5.access(destFile);
       destExists = true;
     } catch {}
     if (destExists) {
       const [srcContent, destContent] = await Promise.all([
-        Bun.file(srcFile).text(),
-        Bun.file(destFile).text()
+        fs5.readFile(srcFile, "utf-8"),
+        fs5.readFile(destFile, "utf-8")
       ]);
       if (srcContent !== destContent) {
         const backupDir = path5.join(root, ".oneagent/backup");
-        await fs4.mkdir(backupDir, { recursive: true });
+        await fs5.mkdir(backupDir, { recursive: true });
         const safeName = path5.relative(root, srcFile).replace(/\//g, "_");
-        await Bun.write(path5.join(backupDir, safeName), srcContent);
+        await fs5.writeFile(path5.join(backupDir, safeName), srcContent);
       }
-      await fs4.unlink(srcFile);
+      await fs5.unlink(srcFile);
     } else {
-      await fs4.rename(srcFile, destFile);
+      await fs5.rename(srcFile, destFile);
     }
   }
 }
 async function migrateAndRemoveDir(src, dest, root) {
   let stat;
   try {
-    stat = await fs4.lstat(src);
+    stat = await fs5.lstat(src);
   } catch {
     return;
   }
   if (stat.isSymbolicLink() || !stat.isDirectory())
     return;
   await migrateFilesFromDir(src, dest, root);
-  await fs4.rm(src, { recursive: true, force: true });
+  await fs5.rm(src, { recursive: true, force: true });
 }
 async function migrateRuleAndSkillFiles(root) {
   const destRules = path5.join(root, ".oneagent/rules");
@@ -8559,11 +8561,11 @@ async function createAllSymlinks(entries) {
 }
 async function checkSymlink(entry) {
   try {
-    const stat = await fs4.lstat(entry.symlinkPath);
+    const stat = await fs5.lstat(entry.symlinkPath);
     if (!stat.isSymbolicLink()) {
       return { ...entry, exists: true, valid: false };
     }
-    const linkTarget = await fs4.readlink(entry.symlinkPath);
+    const linkTarget = await fs5.readlink(entry.symlinkPath);
     return { ...entry, exists: true, valid: linkTarget === entry.target };
   } catch {
     return { ...entry, exists: false, valid: false };
@@ -8573,7 +8575,7 @@ var init_symlinks = () => {};
 
 // ../core/src/copilot.ts
 import path6 from "path";
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 function buildCopilotContent(rule) {
   return `---
 applyTo: "${rule.applyTo}"
@@ -8585,8 +8587,8 @@ function copilotFilePath(root, ruleName) {
 }
 async function generateCopilotRule(root, rule) {
   const filePath = copilotFilePath(root, rule.name);
-  await fs5.mkdir(path6.dirname(filePath), { recursive: true });
-  await Bun.write(filePath, buildCopilotContent(rule));
+  await fs6.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs6.writeFile(filePath, buildCopilotContent(rule));
 }
 async function generateCopilotRules(root, rules) {
   await Promise.all(rules.map((rule) => generateCopilotRule(root, rule)));
@@ -8604,8 +8606,8 @@ function copilotPromptFilePath(root, skillName) {
 }
 async function generateCopilotSkill(root, skill) {
   const filePath = copilotPromptFilePath(root, skill.name);
-  await fs5.mkdir(path6.dirname(filePath), { recursive: true });
-  await Bun.write(filePath, buildCopilotPromptContent(skill));
+  await fs6.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs6.writeFile(filePath, buildCopilotPromptContent(skill));
 }
 async function generateCopilotSkills(root, skills) {
   await Promise.all(skills.map((skill) => generateCopilotSkill(root, skill)));
@@ -8614,9 +8616,10 @@ var init_copilot = () => {};
 
 // ../core/src/opencode.ts
 import path7 from "path";
+import fs7 from "fs/promises";
 async function readOpencode(root) {
   try {
-    const content = await Bun.file(path7.join(root, "opencode.json")).text();
+    const content = await fs7.readFile(path7.join(root, "opencode.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -8631,21 +8634,21 @@ function buildOpencodeConfig(existing) {
 async function writeOpencode(root, _rules) {
   const existing = await readOpencode(root);
   const config = buildOpencodeConfig(existing);
-  await Bun.write(path7.join(root, "opencode.json"), JSON.stringify(config, null, 2) + `
+  await fs7.writeFile(path7.join(root, "opencode.json"), JSON.stringify(config, null, 2) + `
 `);
 }
 var init_opencode = () => {};
 
 // ../core/src/generate.ts
 import path8 from "path";
-import fs6 from "fs/promises";
+import fs8 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, rules),
-    ...buildSkillSymlinks(root, targets, skills)
+    ...buildSkillSymlinks(root, targets)
   ];
   const [mainCollisions, ruleSkillSymlinkCollisions] = await Promise.all([
     Promise.all(mainEntries.map((entry) => readDetectedFile(root, path8.relative(root, entry.symlinkPath)))).then((files) => files.filter((f) => f !== null)),
@@ -8657,10 +8660,10 @@ async function detectGenerateCollisions(root, config) {
       ...rules.map(async (rule) => {
         const filePath = copilotFilePath(root, rule.name);
         try {
-          const content = await Bun.file(filePath).text();
+          const content = await fs8.readFile(filePath, "utf-8");
           if (content === buildCopilotContent(rule))
             return null;
-          const stat = await fs6.lstat(filePath);
+          const stat = await fs8.lstat(filePath);
           return { relativePath: path8.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content };
         } catch {
           return null;
@@ -8669,10 +8672,10 @@ async function detectGenerateCollisions(root, config) {
       ...skills.map(async (skill) => {
         const filePath = copilotPromptFilePath(root, skill.name);
         try {
-          const content = await Bun.file(filePath).text();
+          const content = await fs8.readFile(filePath, "utf-8");
           if (content === buildCopilotPromptContent(skill))
             return null;
-          const stat = await fs6.lstat(filePath);
+          const stat = await fs8.lstat(filePath);
           return { relativePath: path8.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content };
         } catch {
           return null;
@@ -8689,10 +8692,10 @@ async function detectGenerateCollisions(root, config) {
 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, rules);
-  const skillSymlinks = buildSkillSymlinks(root, targets, skills);
-  await migrateRuleAndSkillFiles(root);
+  const skillSymlinks = await buildSkillSymlinks(root, targets);
   await createAllSymlinks([...mainSymlinks, ...rulesSymlinks, ...skillSymlinks, ...buildAgentsDirSymlinks(root)]);
   if (targets.includes("copilot")) {
     await Promise.all([generateCopilotRules(root, rules), generateCopilotSkills(root, skills)]);
@@ -8712,11 +8715,12 @@ var init_generate = __esm(() => {
 });
 
 // ../core/src/status.ts
+import fs9 from "fs/promises";
 async function checkGeneratedFile(root, rule) {
   const filePath = copilotFilePath(root, rule.name);
   const expected = buildCopilotContent(rule);
   try {
-    const content = await Bun.file(filePath).text();
+    const content = await fs9.readFile(filePath, "utf-8");
     return { path: filePath, exists: true, upToDate: content === expected };
   } catch {
     return { path: filePath, exists: false, upToDate: false };
@@ -8732,7 +8736,7 @@ async function checkCopilotPrompt(root, skill) {
   const filePath = copilotPromptFilePath(root, skill.name);
   const expected = buildCopilotPromptContent(skill);
   try {
-    const content = await Bun.file(filePath).text();
+    const content = await fs9.readFile(filePath, "utf-8");
     return { path: filePath, exists: true, upToDate: content === expected };
   } catch {
     return { path: filePath, exists: false, upToDate: false };
@@ -8744,7 +8748,7 @@ async function checkStatus(root, config) {
   const allEntries = [
     ...buildMainSymlinks(root, targets),
     ...buildRulesSymlinks(root, targets, rules),
-    ...buildSkillSymlinks(root, targets, skills),
+    ...buildSkillSymlinks(root, targets),
     ...buildAgentsDirSymlinks(root)
   ];
   const symlinks = await Promise.all(allEntries.map(checkSymlink));
@@ -8766,20 +8770,22 @@ var init_status = __esm(() => {
 
 // ../core/src/apply-template.ts
 import path9 from "path";
-import fs7 from "fs/promises";
+import fs10 from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
 async function applyTemplateFiles(root, template) {
   const oneagentDir = path9.join(root, ".oneagent");
-  await fs7.mkdir(path9.join(oneagentDir, "rules"), { recursive: true });
-  await fs7.mkdir(path9.join(oneagentDir, "skills"), { recursive: true });
-  await Bun.write(path9.join(oneagentDir, "instructions.md"), template.instructions);
+  await fs10.mkdir(path9.join(oneagentDir, "rules"), { recursive: true });
+  await fs10.mkdir(path9.join(oneagentDir, "skills"), { recursive: true });
+  await fs10.writeFile(path9.join(oneagentDir, "instructions.md"), template.instructions);
   for (const rule of template.rules) {
-    await Bun.write(path9.join(oneagentDir, "rules", `${rule.name}.md`), rule.content);
+    await fs10.writeFile(path9.join(oneagentDir, "rules", `${rule.name}.md`), rule.content);
   }
 }
 async function installTemplateSkills(root, template, onSkillInstalled) {
   for (const identifier of template.skills) {
     try {
-      await Bun.$`bunx skills add ${identifier} --agent universal --yes`.cwd(root).quiet();
+      await execFileAsync("npx", ["skills", "add", identifier, "--agent", "universal", "--yes"], { cwd: root });
       onSkillInstalled?.(identifier);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -8849,7 +8855,10 @@ async function fetchGitHubRules(repoUrl) {
     return [];
   }
 }
-var init_apply_template = () => {};
+var execFileAsync;
+var init_apply_template = __esm(() => {
+  execFileAsync = promisify(execFile);
+});
 
 // ../core/src/index.ts
 var init_src = __esm(() => {
@@ -8900,12 +8909,13 @@ var init_utils = __esm(() => {
 
 // ../templates/src/index.ts
 import path10 from "path";
-import fs8 from "fs/promises";
+import fs11 from "fs/promises";
+import { fileURLToPath } from "url";
 async function loadTemplate(name) {
-  const templateDir = path10.join(import.meta.dir, "templates", name);
+  const templateDir = path10.join(__dirname2, "templates", name);
   const [yamlText, instructions] = await Promise.all([
-    Bun.file(path10.join(templateDir, "template.yml")).text(),
-    Bun.file(path10.join(templateDir, "instructions.md")).text()
+    fs11.readFile(path10.join(templateDir, "template.yml"), "utf-8"),
+    fs11.readFile(path10.join(templateDir, "instructions.md"), "utf-8")
   ]);
   const descMatch = yamlText.match(/^description:\s*(.+)$/m);
   const description = descMatch?.[1]?.trim() ?? "";
@@ -8923,10 +8933,10 @@ async function loadTemplate(name) {
   const rulesDir = path10.join(templateDir, "rules");
   let rules2 = [];
   try {
-    const ruleFiles = await fs8.readdir(rulesDir);
+    const ruleFiles = await fs11.readdir(rulesDir);
     rules2 = await Promise.all(ruleFiles.filter((f) => f.endsWith(".md")).map(async (f) => ({
       name: path10.basename(f, ".md"),
-      content: await Bun.file(path10.join(rulesDir, f)).text()
+      content: await fs11.readFile(path10.join(rulesDir, f), "utf-8")
     })));
   } catch {}
   return { name, description, skills: skills2, instructions, rules: rules2 };
@@ -8936,8 +8946,9 @@ async function resolveBuiltinTemplate(name) {
     return null;
   return loadTemplate(name);
 }
-var TEMPLATE_NAMES, BUILTIN_TEMPLATE_NAMES;
+var __dirname2, TEMPLATE_NAMES, BUILTIN_TEMPLATE_NAMES;
 var init_src2 = __esm(() => {
+  __dirname2 = path10.dirname(fileURLToPath(import.meta.url));
   TEMPLATE_NAMES = ["default", "react", "react-native"];
   BUILTIN_TEMPLATE_NAMES = TEMPLATE_NAMES;
 });
@@ -8948,7 +8959,7 @@ __export(exports_init, {
   default: () => init_default
 });
 import path11 from "path";
-import fs9 from "fs/promises";
+import fs12 from "fs/promises";
 function cancelAndExit() {
   Le("Cancelled.");
   process.exit(0);
@@ -9022,10 +9033,10 @@ async function backupFiles(root, files) {
   if (files.length === 0)
     return;
   const backupDir = path11.join(root, ".oneagent/backup");
-  await fs9.mkdir(backupDir, { recursive: true });
+  await fs12.mkdir(backupDir, { recursive: true });
   for (const file of files) {
     const safeName = file.relativePath.replace(/\//g, "_");
-    await Bun.write(path11.join(backupDir, safeName), file.content);
+    await fs12.writeFile(path11.join(backupDir, safeName), file.content);
   }
 }
 async function resolveTemplate(templateArg) {
@@ -9105,8 +9116,8 @@ var init_init = __esm(() => {
       const selectedTargets = await pickTargets();
       const s = bt2();
       s.start("Setting up .oneagent/ directory...");
-      await fs9.mkdir(path11.join(root, ".oneagent/rules"), { recursive: true });
-      await fs9.mkdir(path11.join(root, ".oneagent/skills"), { recursive: true });
+      await fs12.mkdir(path11.join(root, ".oneagent/rules"), { recursive: true });
+      await fs12.mkdir(path11.join(root, ".oneagent/skills"), { recursive: true });
       await backupFiles(root, detected);
       await removeDeprecatedFiles(root);
       await warnDeprecatedCommandFiles(root);
@@ -9120,9 +9131,9 @@ var init_init = __esm(() => {
 
 Add your AI instructions here.
 `;
-        await Bun.write(path11.join(root, ".oneagent/instructions.md"), instructionsContent);
+        await fs12.writeFile(path11.join(root, ".oneagent/instructions.md"), instructionsContent);
       }
-      await Bun.write(path11.join(root, ".oneagent/rules/oneagent.md"), DOTAI_META_RULE);
+      await fs12.writeFile(path11.join(root, ".oneagent/rules/oneagent.md"), DOTAI_META_RULE);
       s.stop("Directory structure created.");
       const s2 = bt2();
       s2.start("Generating symlinks and agent files...");
@@ -9158,7 +9169,7 @@ __export(exports_generate, {
   default: () => generate_default
 });
 import path12 from "path";
-import fs10 from "fs/promises";
+import fs13 from "fs/promises";
 var generate_default;
 var init_generate2 = __esm(() => {
   init_dist();
@@ -9182,10 +9193,10 @@ var init_generate2 = __esm(() => {
       const { mainFiles, ruleSkillFiles } = await detectGenerateCollisions(root, config2);
       if (mainFiles.length > 0) {
         const backupDir = path12.join(root, ".oneagent/backup");
-        await fs10.mkdir(backupDir, { recursive: true });
+        await fs13.mkdir(backupDir, { recursive: true });
         for (const file of mainFiles) {
           const safeName = file.relativePath.replace(/\//g, "_");
-          await Bun.write(path12.join(backupDir, safeName), file.content);
+          await fs13.writeFile(path12.join(backupDir, safeName), file.content);
         }
       }
       await warnDeprecatedCommandFiles(root);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oneagent",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "description": "One source of truth for AI agent rules — distributed via symlinks to Claude, Cursor, Windsurf, Copilot, OpenCode",
   "license": "MIT",