oneagent 0.2.3 → 0.2.5

package/dist/index.js

@@ -1290,6 +1290,57 @@ var init_dist3 = __esm(() => {
   zt = { light: C("─", "-"), heavy: C("━", "="), block: C("█", "#") };
   Qt = `${import_picocolors2.default.gray(d)}  `;
 });
+// ../core/src/agents.ts
+var AGENT_DEFINITIONS;
+var init_agents = __esm(() => {
+  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"
+    },
+    {
+      target: "cursor",
+      displayName: "Cursor",
+      hint: "AGENTS.md + .cursor/rules/",
+      detectIndicators: [".cursor", ".cursorrules"],
+      mainFile: "AGENTS.md",
+      rulesDir: ".cursor/rules",
+      skillsDir: ".cursor/skills",
+      deprecatedFiles: [".cursorrules"]
+    },
+    {
+      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.json",
+      detectIndicators: ["opencode.json", ".opencode"],
+      mainFile: "AGENTS.md"
+    },
+    {
+      target: "copilot",
+      displayName: "GitHub Copilot",
+      hint: ".github/instructions/*.instructions.md",
+      detectIndicators: [".github/copilot-instructions.md", ".github"],
+      mainFile: ".github/copilot-instructions.md",
+      skillsDir: ".github/skills"
+    }
+  ];
+});
+
 // ../../node_modules/.bun/yaml@2.8.2/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS((exports) => {
   var ALIAS = Symbol.for("yaml.alias");
@@ -8243,6 +8294,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]);
 }
@@ -8250,15 +8302,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(() => {
@@ -8268,18 +8321,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,
@@ -8305,16 +8358,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 [];
@@ -8322,6 +8375,7 @@ async function detectDeprecatedCommandFiles(root) {
 }
 var AGENT_FILES, DEPRECATED_FILES;
 var init_detect = __esm(() => {
+  init_agents();
   AGENT_FILES = [
     "CLAUDE.md",
     "AGENTS.md",
@@ -8329,12 +8383,12 @@ var init_detect = __esm(() => {
     ".windsurfrules",
     ".github/copilot-instructions.md"
   ];
-  DEPRECATED_FILES = [".cursorrules"];
+  DEPRECATED_FILES = AGENT_DEFINITIONS.flatMap((d2) => d2.deprecatedFiles ?? []);
 });
 
 // ../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)
@@ -8346,14 +8400,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));
@@ -8365,7 +8419,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)
@@ -8380,14 +8434,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));
@@ -8402,16 +8456,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);
@@ -8420,24 +8474,8 @@ function buildMainSymlinks(root, targets) {
   const instructionsAbs = path5.join(root, ".oneagent/instructions.md");
   const seen = new Map;
   for (const target of targets) {
-    let symlinkPath;
-    switch (target) {
-      case "claude":
-        symlinkPath = path5.join(root, "CLAUDE.md");
-        break;
-      case "cursor":
-        symlinkPath = path5.join(root, "AGENTS.md");
-        break;
-      case "windsurf":
-        symlinkPath = path5.join(root, ".windsurfrules");
-        break;
-      case "opencode":
-        symlinkPath = path5.join(root, "AGENTS.md");
-        break;
-      case "copilot":
-        symlinkPath = path5.join(root, ".github/copilot-instructions.md");
-        break;
-    }
+    const def = AGENT_DEFINITIONS.find((d2) => d2.target === target);
+    const symlinkPath = path5.join(root, def.mainFile);
     if (!seen.has(symlinkPath)) {
       seen.set(symlinkPath, {
         symlinkPath,
@@ -8448,49 +8486,18 @@ function buildMainSymlinks(root, targets) {
   }
   return Array.from(seen.values());
 }
-function buildRulesSymlinks(root, targets, rules) {
-  const entries = [];
-  for (const target of targets) {
-    let rulesDir = null;
-    switch (target) {
-      case "claude":
-        rulesDir = path5.join(root, ".claude/rules");
-        break;
-      case "cursor":
-        rulesDir = path5.join(root, ".cursor/rules");
-        break;
-      case "windsurf":
-        rulesDir = path5.join(root, ".windsurf/rules");
-        break;
-      case "opencode":
-      case "copilot":
-        rulesDir = null;
-        break;
-    }
-    if (!rulesDir)
-      continue;
-    for (const rule of rules) {
-      const symlinkPath = path5.join(rulesDir, `${rule.name}.md`);
-      entries.push({
-        symlinkPath,
-        target: relativeTarget(symlinkPath, rule.path),
-        label: path5.relative(root, symlinkPath)
-      });
-    }
-  }
-  return entries;
+function buildRulesSymlinks(root, targets) {
+  const targetAbs = path5.join(root, ".oneagent/rules");
+  return AGENT_DEFINITIONS.filter((d2) => targets.includes(d2.target) && d2.rulesDir).map((d2) => {
+    const symlinkPath = path5.join(root, d2.rulesDir);
+    return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d2.rulesDir };
+  });
 }
-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");
+  return AGENT_DEFINITIONS.filter((d2) => targets.includes(d2.target) && d2.skillsDir).map((d2) => {
+    const symlinkPath = path5.join(root, d2.skillsDir);
+    return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d2.skillsDir };
   });
 }
 function buildAgentsDirSymlinks(root) {
@@ -8499,10 +8506,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;
   }
@@ -8513,37 +8520,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");
@@ -8558,21 +8565,23 @@ 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 };
   }
 }
-var init_symlinks = () => {};
+var init_symlinks = __esm(() => {
+  init_agents();
+});
 
 // ../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}"
@@ -8584,8 +8593,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)));
@@ -8603,8 +8612,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)));
@@ -8613,9 +8622,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;
@@ -8630,21 +8640,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)
+    ...buildRulesSymlinks(root, targets),
+    ...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)),
@@ -8656,10 +8666,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;
@@ -8668,10 +8678,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;
@@ -8688,10 +8698,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);
-  const mainSymlinks = buildMainSymlinks(root, targets);
-  const rulesSymlinks = buildRulesSymlinks(root, targets, rules);
-  const skillSymlinks = buildSkillSymlinks(root, targets, skills);
   await migrateRuleAndSkillFiles(root);
+  const mainSymlinks = buildMainSymlinks(root, targets);
+  const rulesSymlinks = buildRulesSymlinks(root, targets);
+  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)]);
@@ -8711,11 +8721,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 };
@@ -8731,7 +8742,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 };
@@ -8742,8 +8753,8 @@ async function checkStatus(root, config) {
   const targets = activeTargets(config);
   const allEntries = [
     ...buildMainSymlinks(root, targets),
-    ...buildRulesSymlinks(root, targets, rules),
-    ...buildSkillSymlinks(root, targets, skills),
+    ...buildRulesSymlinks(root, targets),
+    ...buildSkillSymlinks(root, targets),
     ...buildAgentsDirSymlinks(root)
   ];
   const symlinks = await Promise.all(allEntries.map(checkSymlink));
@@ -8765,20 +8776,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);
@@ -8848,10 +8861,14 @@ 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(() => {
+  init_agents();
   init_config();
   init_detect();
   init_rules();
@@ -8899,12 +8916,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() ?? "";
@@ -8922,10 +8940,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 };
@@ -8935,8 +8953,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;
 });
@@ -8947,7 +8966,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);
@@ -8999,18 +9018,24 @@ async function chooseContent(detected) {
   const index = parseInt(result.replace("file:", ""), 10);
   return detected[index].content;
 }
-async function pickTargets() {
+async function detectPresentTargets(root) {
+  const results = await Promise.all(AGENT_DEFINITIONS.map(async (def) => {
+    for (const indicator of def.detectIndicators) {
+      try {
+        await fs12.access(path11.join(root, indicator));
+        return def.target;
+      } catch {}
+    }
+    return null;
+  }));
+  return results.filter((t) => t !== null);
+}
+async function pickTargets(initialValues) {
   const result = await je({
     message: `Which AI agents do you want to support?
 \x1B[90m · Space to toggle · Enter to confirm\x1B[39m`,
-    options: [
-      { value: "claude", label: "Claude Code", hint: "CLAUDE.md + .claude/rules/" },
-      { value: "cursor", label: "Cursor", hint: "AGENTS.md + .cursor/rules/" },
-      { value: "windsurf", label: "Windsurf", hint: ".windsurfrules + .windsurf/rules/" },
-      { value: "opencode", label: "OpenCode", hint: "AGENTS.md + opencode.json" },
-      { value: "copilot", label: "GitHub Copilot", hint: ".github/instructions/*.instructions.md" }
-    ],
-    initialValues: ["claude"],
+    options: AGENT_DEFINITIONS.map((d2) => ({ value: d2.target, label: d2.displayName, hint: d2.hint })),
+    initialValues,
     required: true
   });
   if (Ct(result))
@@ -9021,10 +9046,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) {
@@ -9101,11 +9126,12 @@ var init_init = __esm(() => {
       } else {
         importedContent = await chooseContent(detected);
       }
-      const selectedTargets = await pickTargets();
+      const presentTargets = await detectPresentTargets(root);
+      const selectedTargets = await pickTargets(presentTargets);
       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);
@@ -9119,9 +9145,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...");
@@ -9157,7 +9183,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();
@@ -9181,10 +9207,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.3",
+  "version": "0.2.5",
   "type": "module",
   "description": "One source of truth for AI agent rules — distributed via symlinks to Claude, Cursor, Windsurf, Copilot, OpenCode",
   "license": "MIT",