@omnidev-ai/core 0.5.2 → 0.5.3

package/dist/index.js

@@ -8,6 +8,7 @@ import { buildCommand, buildRouteMap } from "@stricli/core";
 
 // src/capability/commands.ts
 import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 
 // src/capability/yaml-parser.ts
@@ -63,7 +64,7 @@ async function loadCommands(capabilityPath, capabilityId) {
   return commands;
 }
 async function parseCommandFile(filePath, capabilityId) {
-  const content = await Bun.file(filePath).text();
+  const content = await readFile(filePath, "utf-8");
   const parsed = parseFrontmatterWithMarkdown(content);
   if (!parsed) {
     throw new Error(`Invalid COMMAND.md format at ${filePath}: missing YAML frontmatter`);
@@ -86,12 +87,13 @@ async function parseCommandFile(filePath, capabilityId) {
 }
 // src/capability/docs.ts
 import { existsSync as existsSync2, readdirSync as readdirSync2 } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
 import { basename, join as join2 } from "node:path";
 async function loadDocs(capabilityPath, capabilityId) {
   const docs = [];
   const definitionPath = join2(capabilityPath, "definition.md");
   if (existsSync2(definitionPath)) {
-    const content = await Bun.file(definitionPath).text();
+    const content = await readFile2(definitionPath, "utf-8");
     docs.push({
       name: "definition",
       content: content.trim(),
@@ -104,7 +106,7 @@ async function loadDocs(capabilityPath, capabilityId) {
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
         const docPath = join2(docsDir, entry.name);
-        const content = await Bun.file(docPath).text();
+        const content = await readFile2(docPath, "utf-8");
         docs.push({
           name: basename(entry.name, ".md"),
           content: content.trim(),
@@ -117,15 +119,17 @@ async function loadDocs(capabilityPath, capabilityId) {
 }
 // src/capability/loader.ts
 import { existsSync as existsSync7, readdirSync as readdirSync6 } from "node:fs";
+import { readFile as readFile7 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 
 // src/config/env.ts
 import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
 var ENV_FILE = ".omni/.env";
 async function loadEnvironment() {
   const env = {};
   if (existsSync3(ENV_FILE)) {
-    const content = await Bun.file(ENV_FILE).text();
+    const content = await readFile3(ENV_FILE, "utf-8");
     for (const line of content.split(`
 `)) {
       const trimmed = line.trim();
@@ -205,6 +209,7 @@ function parseCapabilityConfig(tomlContent) {
 
 // src/capability/rules.ts
 import { existsSync as existsSync4, readdirSync as readdirSync3 } from "node:fs";
+import { readFile as readFile4, writeFile } from "node:fs/promises";
 import { basename as basename2, join as join3 } from "node:path";
 async function loadRules(capabilityPath, capabilityId) {
   const rulesDir = join3(capabilityPath, "rules");
@@ -216,7 +221,7 @@ async function loadRules(capabilityPath, capabilityId) {
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".md")) {
       const rulePath = join3(rulesDir, entry.name);
-      const content = await Bun.file(rulePath).text();
+      const content = await readFile4(rulePath, "utf-8");
       rules.push({
         name: basename2(entry.name, ".md"),
         content: content.trim(),
@@ -231,7 +236,7 @@ async function writeRules(rules, docs = []) {
   const rulesContent = generateRulesContent(rules, docs);
   let content;
   if (existsSync4(instructionsPath)) {
-    content = await Bun.file(instructionsPath).text();
+    content = await readFile4(instructionsPath, "utf-8");
   } else {
     content = `# OmniDev Instructions
 
@@ -259,7 +264,7 @@ ${endMarker}
 ` + rulesContent + `
 ` + content.substring(endIndex);
   }
-  await Bun.write(instructionsPath, content);
+  await writeFile(instructionsPath, content, "utf-8");
 }
 function generateRulesContent(rules, docs = []) {
   if (rules.length === 0 && docs.length === 0) {
@@ -303,6 +308,7 @@ ${rule.content}
 
 // src/capability/skills.ts
 import { existsSync as existsSync5, readdirSync as readdirSync4 } from "node:fs";
+import { readFile as readFile5 } from "node:fs/promises";
 import { join as join4 } from "node:path";
 async function loadSkills(capabilityPath, capabilityId) {
   const skillsDir = join4(capabilityPath, "skills");
@@ -323,7 +329,7 @@ async function loadSkills(capabilityPath, capabilityId) {
   return skills;
 }
 async function parseSkillFile(filePath, capabilityId) {
-  const content = await Bun.file(filePath).text();
+  const content = await readFile5(filePath, "utf-8");
   const parsed = parseFrontmatterWithMarkdown(content);
   if (!parsed) {
     throw new Error(`Invalid SKILL.md format at ${filePath}: missing YAML frontmatter`);
@@ -343,6 +349,7 @@ async function parseSkillFile(filePath, capabilityId) {
 
 // src/capability/subagents.ts
 import { existsSync as existsSync6, readdirSync as readdirSync5 } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 async function loadSubagents(capabilityPath, capabilityId) {
   const subagentsDir = join5(capabilityPath, "subagents");
@@ -363,7 +370,7 @@ async function loadSubagents(capabilityPath, capabilityId) {
   return subagents;
 }
 async function parseSubagentFile(filePath, capabilityId) {
-  const content = await Bun.file(filePath).text();
+  const content = await readFile6(filePath, "utf-8");
   const parsed = parseFrontmatterWithMarkdown(content);
   if (!parsed) {
     throw new Error(`Invalid SUBAGENT.md format at ${filePath}: missing YAML frontmatter`);
@@ -423,7 +430,7 @@ async function discoverCapabilities() {
 }
 async function loadCapabilityConfig(capabilityPath) {
   const configPath = join6(capabilityPath, "capability.toml");
-  const content = await Bun.file(configPath).text();
+  const content = await readFile7(configPath, "utf-8");
   const config = parseCapabilityConfig(content);
   return config;
 }
@@ -452,7 +459,7 @@ async function loadTypeDefinitions(capabilityPath) {
   if (!existsSync7(typesPath)) {
     return;
   }
-  return Bun.file(typesPath).text();
+  return readFile7(typesPath, "utf-8");
 }
 function convertSkillExports(skillExports, capabilityId) {
   return skillExports.map((skillExport) => {
@@ -666,6 +673,7 @@ async function loadCapability(capabilityPath, env) {
 }
 // src/config/loader.ts
 import { existsSync as existsSync8 } from "node:fs";
+import { readFile as readFile8, writeFile as writeFile2 } from "node:fs/promises";
 var CONFIG_PATH = "omni.toml";
 var LOCAL_CONFIG = "omni.local.toml";
 function mergeConfigs(base, override) {
@@ -687,18 +695,18 @@ async function loadConfig() {
   let baseConfig = {};
   let localConfig = {};
   if (existsSync8(CONFIG_PATH)) {
-    const content = await Bun.file(CONFIG_PATH).text();
+    const content = await readFile8(CONFIG_PATH, "utf-8");
     baseConfig = parseOmniConfig(content);
   }
   if (existsSync8(LOCAL_CONFIG)) {
-    const content = await Bun.file(LOCAL_CONFIG).text();
+    const content = await readFile8(LOCAL_CONFIG, "utf-8");
     localConfig = parseOmniConfig(content);
   }
   return mergeConfigs(baseConfig, localConfig);
 }
 async function writeConfig(config) {
   const content = generateConfigToml(config);
-  await Bun.write(CONFIG_PATH, content);
+  await writeFile2(CONFIG_PATH, content, "utf-8");
 }
 function generateConfigToml(config) {
   const lines = [];
@@ -812,6 +820,7 @@ function generateConfigToml(config) {
 
 // src/state/active-profile.ts
 import { existsSync as existsSync9, mkdirSync } from "node:fs";
+import { readFile as readFile9, unlink, writeFile as writeFile3 } from "node:fs/promises";
 var STATE_DIR = ".omni/state";
 var ACTIVE_PROFILE_PATH = `${STATE_DIR}/active-profile`;
 async function readActiveProfileState() {
@@ -819,7 +828,7 @@ async function readActiveProfileState() {
     return null;
   }
   try {
-    const content = await Bun.file(ACTIVE_PROFILE_PATH).text();
+    const content = await readFile9(ACTIVE_PROFILE_PATH, "utf-8");
     const trimmed = content.trim();
     return trimmed || null;
   } catch {
@@ -828,12 +837,11 @@ async function readActiveProfileState() {
 }
 async function writeActiveProfileState(profileName) {
   mkdirSync(STATE_DIR, { recursive: true });
-  await Bun.write(ACTIVE_PROFILE_PATH, profileName);
+  await writeFile3(ACTIVE_PROFILE_PATH, profileName, "utf-8");
 }
 async function clearActiveProfileState() {
   if (existsSync9(ACTIVE_PROFILE_PATH)) {
-    const file = Bun.file(ACTIVE_PROFILE_PATH);
-    await file.delete();
+    await unlink(ACTIVE_PROFILE_PATH);
   }
 }
 
@@ -929,7 +937,8 @@ async function buildCapabilityRegistry() {
 }
 // src/capability/sources.ts
 import { existsSync as existsSync10 } from "node:fs";
-import { cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { cp, mkdir, readdir, readFile as readFile10, rm, stat, writeFile as writeFile4 } from "node:fs/promises";
 import { join as join7 } from "node:path";
 import { parse as parseToml } from "smol-toml";
 var OMNI_LOCAL = ".omni";
@@ -941,6 +950,28 @@ var DOC_DIRS = ["docs", "doc", "documentation"];
 var SKILL_FILES = ["SKILL.md", "skill.md", "Skill.md"];
 var AGENT_FILES = ["AGENT.md", "agent.md", "Agent.md", "SUBAGENT.md", "subagent.md"];
 var COMMAND_FILES = ["COMMAND.md", "command.md", "Command.md"];
+async function spawnCapture(command, args, options) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options?.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.setEncoding("utf-8");
+    child.stderr?.setEncoding("utf-8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => reject(error));
+    child.on("close", (exitCode) => {
+      resolve({ exitCode: exitCode ?? 0, stdout, stderr });
+    });
+  });
+}
 function parseSourceConfig(source) {
   if (typeof source === "string") {
     let sourceUrl = source;
@@ -977,7 +1008,7 @@ async function loadLockFile() {
     return { capabilities: {} };
   }
   try {
-    const content = await readFile(lockPath, "utf-8");
+    const content = await readFile10(lockPath, "utf-8");
     const parsed = parseToml(content);
     const capabilities = parsed["capabilities"];
     return {
@@ -1014,17 +1045,16 @@ async function saveLockFile(lockFile) {
 
 `;
   const content = header + stringifyLockFile(lockFile);
-  await writeFile(lockPath, content, "utf-8");
+  await writeFile4(lockPath, content, "utf-8");
 }
 async function getRepoCommit(repoPath) {
-  const proc = Bun.spawn(["git", "rev-parse", "HEAD"], {
-    cwd: repoPath,
-    stdout: "pipe",
-    stderr: "pipe"
+  const { exitCode, stdout, stderr } = await spawnCapture("git", ["rev-parse", "HEAD"], {
+    cwd: repoPath
   });
-  const output = await new Response(proc.stdout).text();
-  await proc.exited;
-  return output.trim();
+  if (exitCode !== 0) {
+    throw new Error(`Failed to get commit for ${repoPath}: ${stderr.trim()}`);
+  }
+  return stdout.trim();
 }
 function shortCommit(commit) {
   return commit.substring(0, 7);
@@ -1036,42 +1066,34 @@ async function cloneRepo(gitUrl, targetPath, ref) {
     args.push("--branch", ref);
   }
   args.push(gitUrl, targetPath);
-  const proc = Bun.spawn(["git", ...args], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  await proc.exited;
-  if (proc.exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`Failed to clone ${gitUrl}: ${stderr}`);
+  const { exitCode, stderr } = await spawnCapture("git", args);
+  if (exitCode !== 0) {
+    throw new Error(`Failed to clone ${gitUrl}: ${stderr.trim()}`);
   }
 }
 async function fetchRepo(repoPath, ref) {
-  const fetchProc = Bun.spawn(["git", "fetch", "--depth", "1", "origin"], {
-    cwd: repoPath,
-    stdout: "pipe",
-    stderr: "pipe"
+  const fetchResult = await spawnCapture("git", ["fetch", "--depth", "1", "origin"], {
+    cwd: repoPath
   });
-  await fetchProc.exited;
+  if (fetchResult.exitCode !== 0) {
+    throw new Error(`Failed to fetch in ${repoPath}: ${fetchResult.stderr.trim()}`);
+  }
   const currentCommit = await getRepoCommit(repoPath);
   const targetRef = ref || "HEAD";
-  const lsProc = Bun.spawn(["git", "ls-remote", "origin", targetRef], {
-    cwd: repoPath,
-    stdout: "pipe",
-    stderr: "pipe"
+  const lsResult = await spawnCapture("git", ["ls-remote", "origin", targetRef], {
+    cwd: repoPath
   });
-  const lsOutput = await new Response(lsProc.stdout).text();
-  await lsProc.exited;
-  const remoteCommit = lsOutput.split("\t")[0];
+  if (lsResult.exitCode !== 0) {
+    throw new Error(`Failed to ls-remote in ${repoPath}: ${lsResult.stderr.trim()}`);
+  }
+  const remoteCommit = lsResult.stdout.split("\t")[0];
   if (currentCommit === remoteCommit) {
     return false;
   }
-  const pullProc = Bun.spawn(["git", "pull", "--ff-only"], {
-    cwd: repoPath,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  await pullProc.exited;
+  const pullResult = await spawnCapture("git", ["pull", "--ff-only"], { cwd: repoPath });
+  if (pullResult.exitCode !== 0) {
+    throw new Error(`Failed to pull in ${repoPath}: ${pullResult.stderr.trim()}`);
+  }
   return true;
 }
 function hasCapabilityToml(dirPath) {
@@ -1141,7 +1163,7 @@ async function parsePluginJson(dirPath) {
     return null;
   }
   try {
-    const content = await readFile(pluginJsonPath, "utf-8");
+    const content = await readFile10(pluginJsonPath, "utf-8");
     const data = JSON.parse(content);
     const result = {
       name: data.name,
@@ -1166,7 +1188,7 @@ async function readReadmeDescription(dirPath) {
     return null;
   }
   try {
-    const content = await readFile(readmePath, "utf-8");
+    const content = await readFile10(readmePath, "utf-8");
     const lines = content.split(`
 `);
     let description = "";
@@ -1271,7 +1293,7 @@ repository = "${repoUrl}"
 wrapped = true
 commit = "${commit}"
 `;
-  await writeFile(join7(repoPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile4(join7(repoPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function fetchGitCapabilitySource(id, config, options) {
   const gitUrl = sourceToGitUrl(config.source);
@@ -1347,7 +1369,7 @@ async function fetchGitCapabilitySource(id, config, options) {
   const pkgJsonPath = join7(repoPath, "package.json");
   if (existsSync10(pkgJsonPath)) {
     try {
-      const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(await readFile10(pkgJsonPath, "utf-8"));
       if (pkgJson.version) {
         version = pkgJson.version;
       }
@@ -1407,7 +1429,7 @@ command = "${mcpConfig.command}"
 }
 async function generateMcpCapabilityToml(id, mcpConfig, targetPath) {
   const tomlContent = generateMcpCapabilityTomlContent(id, mcpConfig);
-  await writeFile(join7(targetPath, "capability.toml"), tomlContent, "utf-8");
+  await writeFile4(join7(targetPath, "capability.toml"), tomlContent, "utf-8");
 }
 async function isGeneratedMcpCapability(capabilityDir) {
   const tomlPath = join7(capabilityDir, "capability.toml");
@@ -1416,7 +1438,7 @@ async function isGeneratedMcpCapability(capabilityDir) {
     return false;
   }
   try {
-    const content = await readFile(tomlPath, "utf-8");
+    const content = await readFile10(tomlPath, "utf-8");
     const parsed = parseToml(content);
     const capability = parsed["capability"];
     const metadata = capability?.["metadata"];
@@ -1533,21 +1555,20 @@ async function checkForUpdates(config) {
       });
       continue;
     }
-    const fetchProc = Bun.spawn(["git", "fetch", "--depth", "1", "origin"], {
-      cwd: targetPath,
-      stdout: "pipe",
-      stderr: "pipe"
+    const fetchResult = await spawnCapture("git", ["fetch", "--depth", "1", "origin"], {
+      cwd: targetPath
     });
-    await fetchProc.exited;
+    if (fetchResult.exitCode !== 0) {
+      throw new Error(`Failed to fetch in ${targetPath}: ${fetchResult.stderr.trim()}`);
+    }
     const targetRef = gitConfig.ref || "HEAD";
-    const lsProc = Bun.spawn(["git", "ls-remote", "origin", targetRef], {
-      cwd: targetPath,
-      stdout: "pipe",
-      stderr: "pipe"
+    const lsResult = await spawnCapture("git", ["ls-remote", "origin", targetRef], {
+      cwd: targetPath
     });
-    const lsOutput = await new Response(lsProc.stdout).text();
-    await lsProc.exited;
-    const remoteCommit = lsOutput.split("\t")[0] || "";
+    if (lsResult.exitCode !== 0) {
+      throw new Error(`Failed to ls-remote in ${targetPath}: ${lsResult.stderr.trim()}`);
+    }
+    const remoteCommit = lsResult.stdout.split("\t")[0] || "";
     const currentCommit = existing?.commit || "";
     updates.push({
       id,
@@ -1561,13 +1582,14 @@ async function checkForUpdates(config) {
 }
 // src/config/provider.ts
 import { existsSync as existsSync11 } from "node:fs";
+import { readFile as readFile11, writeFile as writeFile5 } from "node:fs/promises";
 import { parse as parse2 } from "smol-toml";
 var PROVIDER_CONFIG_PATH = ".omni/provider.toml";
 async function loadProviderConfig() {
   if (!existsSync11(PROVIDER_CONFIG_PATH)) {
     return { provider: "claude" };
   }
-  const content = await Bun.file(PROVIDER_CONFIG_PATH).text();
+  const content = await readFile11(PROVIDER_CONFIG_PATH, "utf-8");
   const parsed = parse2(content);
   return parsed;
 }
@@ -1594,9 +1616,9 @@ async function writeProviderConfig(config) {
     lines.push("# Default: Claude");
     lines.push('provider = "claude"');
   }
-  await Bun.write(PROVIDER_CONFIG_PATH, `${lines.join(`
+  await writeFile5(PROVIDER_CONFIG_PATH, `${lines.join(`
 `)}
-`);
+`, "utf-8");
 }
 function parseProviderFlag(flag) {
   const lower = flag.toLowerCase();
@@ -1610,13 +1632,14 @@ function parseProviderFlag(flag) {
 }
 // src/mcp-json/manager.ts
 import { existsSync as existsSync12 } from "node:fs";
+import { readFile as readFile12, writeFile as writeFile6 } from "node:fs/promises";
 var MCP_JSON_PATH = ".mcp.json";
 async function readMcpJson() {
   if (!existsSync12(MCP_JSON_PATH)) {
     return { mcpServers: {} };
   }
   try {
-    const content = await Bun.file(MCP_JSON_PATH).text();
+    const content = await readFile12(MCP_JSON_PATH, "utf-8");
     const parsed = JSON.parse(content);
     return {
       mcpServers: parsed.mcpServers || {}
@@ -1626,7 +1649,8 @@ async function readMcpJson() {
   }
 }
 async function writeMcpJson(config) {
-  await Bun.write(MCP_JSON_PATH, JSON.stringify(config, null, 2));
+  await writeFile6(MCP_JSON_PATH, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
 }
 function buildMcpServerConfig(mcp) {
   const config = {
@@ -1665,6 +1689,7 @@ async function syncMcpJson(capabilities2, previousManifest, options = {}) {
 }
 // src/state/manifest.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync2, rmSync } from "node:fs";
+import { readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
 var MANIFEST_PATH = ".omni/state/manifest.json";
 var CURRENT_VERSION = 1;
 async function loadManifest() {
@@ -1675,12 +1700,13 @@ async function loadManifest() {
       capabilities: {}
     };
   }
-  const content = await Bun.file(MANIFEST_PATH).text();
+  const content = await readFile13(MANIFEST_PATH, "utf-8");
   return JSON.parse(content);
 }
 async function saveManifest(manifest) {
   mkdirSync2(".omni/state", { recursive: true });
-  await Bun.write(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+  await writeFile7(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
 }
 function buildManifestFromCapabilities(capabilities2) {
   const manifest = {
@@ -1731,6 +1757,7 @@ async function cleanupStaleResources(previousManifest, currentCapabilityIds) {
 }
 // src/state/providers.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync3 } from "node:fs";
+import { readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
 var STATE_DIR2 = ".omni/state";
 var PROVIDERS_PATH = `${STATE_DIR2}/providers.json`;
 var DEFAULT_PROVIDERS = ["claude-code"];
@@ -1739,7 +1766,7 @@ async function readEnabledProviders() {
     return DEFAULT_PROVIDERS;
   }
   try {
-    const content = await Bun.file(PROVIDERS_PATH).text();
+    const content = await readFile14(PROVIDERS_PATH, "utf-8");
     const state = JSON.parse(content);
     return state.enabled.length > 0 ? state.enabled : DEFAULT_PROVIDERS;
   } catch {
@@ -1749,7 +1776,8 @@ async function readEnabledProviders() {
 async function writeEnabledProviders(providers) {
   mkdirSync3(STATE_DIR2, { recursive: true });
   const state = { enabled: providers };
-  await Bun.write(PROVIDERS_PATH, JSON.stringify(state, null, 2));
+  await writeFile8(PROVIDERS_PATH, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
 }
 async function enableProvider(providerId) {
   const current = await readEnabledProviders();
@@ -1767,7 +1795,7 @@ async function isProviderEnabled(providerId) {
   return current.includes(providerId);
 }
 // src/sync.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { mkdirSync as mkdirSync4 } from "node:fs";
 async function installCapabilityDependencies(silent) {
   const { existsSync: existsSync15, readdirSync: readdirSync7 } = await import("node:fs");
@@ -1777,6 +1805,18 @@ async function installCapabilityDependencies(silent) {
     return;
   }
   const entries = readdirSync7(capabilitiesDir, { withFileTypes: true });
+  async function commandExists(cmd) {
+    return await new Promise((resolve) => {
+      const proc = spawn2(cmd, ["--version"], { stdio: "ignore" });
+      proc.on("error", () => resolve(false));
+      proc.on("close", (code) => resolve(code === 0));
+    });
+  }
+  const hasBun = await commandExists("bun");
+  const hasNpm = hasBun ? false : await commandExists("npm");
+  if (!hasBun && !hasNpm) {
+    throw new Error("Neither Bun nor npm is installed. Install one of them to install capability dependencies.");
+  }
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
@@ -1790,7 +1830,10 @@ async function installCapabilityDependencies(silent) {
       console.log(`Installing dependencies for ${capabilityPath}...`);
     }
     await new Promise((resolve, reject) => {
-      const proc = spawn("bun", ["install"], {
+      const useNpmCi = hasNpm && existsSync15(join8(capabilityPath, "package-lock.json"));
+      const cmd = hasBun ? "bun" : "npm";
+      const args = hasBun ? ["install"] : useNpmCi ? ["ci"] : ["install"];
+      const proc = spawn2(cmd, args, {
         cwd: capabilityPath,
         stdio: silent ? "ignore" : "inherit"
       });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@omnidev-ai/core",
-	"version": "0.5.2",
+	"version": "0.5.3",
 	"type": "module",
 	"license": "MIT",
 	"repository": {

package/src/capability/commands.ts

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { Command } from "../types";
 import { parseFrontmatterWithMarkdown } from "./yaml-parser";
@@ -42,7 +43,7 @@ export async function loadCommands(
 }
 
 async function parseCommandFile(filePath: string, capabilityId: string): Promise<Command> {
-	const content = await Bun.file(filePath).text();
+	const content = await readFile(filePath, "utf-8");
 	const parsed = parseFrontmatterWithMarkdown<CommandFrontmatter>(content);
 
 	if (!parsed) {

package/src/capability/docs.ts

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import type { Doc } from "../types";
 
@@ -15,7 +16,7 @@ export async function loadDocs(capabilityPath: string, capabilityId: string): Pr
 	// Load definition.md if exists
 	const definitionPath = join(capabilityPath, "definition.md");
 	if (existsSync(definitionPath)) {
-		const content = await Bun.file(definitionPath).text();
+		const content = await readFile(definitionPath, "utf-8");
 		docs.push({
 			name: "definition",
 			content: content.trim(),
@@ -33,7 +34,7 @@ export async function loadDocs(capabilityPath: string, capabilityId: string): Pr
 		for (const entry of entries) {
 			if (entry.isFile() && entry.name.endsWith(".md")) {
 				const docPath = join(docsDir, entry.name);
-				const content = await Bun.file(docPath).text();
+				const content = await readFile(docPath, "utf-8");
 
 				docs.push({
 					name: basename(entry.name, ".md"),

package/src/capability/loader.ts

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { validateEnv } from "../config/env";
 import { parseCapabilityConfig } from "../config/parser";
@@ -63,7 +64,7 @@ export async function discoverCapabilities(): Promise<string[]> {
  */
 export async function loadCapabilityConfig(capabilityPath: string): Promise<CapabilityConfig> {
 	const configPath = join(capabilityPath, "capability.toml");
-	const content = await Bun.file(configPath).text();
+	const content = await readFile(configPath, "utf-8");
 	const config = parseCapabilityConfig(content);
 
 	return config;
@@ -116,7 +117,7 @@ async function loadTypeDefinitions(capabilityPath: string): Promise<string | und
 		return undefined;
 	}
 
-	return Bun.file(typesPath).text();
+	return readFile(typesPath, "utf-8");
 }
 
 /**

package/src/capability/rules.ts

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import type { Doc, Rule } from "../types";
 
@@ -23,7 +24,7 @@ export async function loadRules(capabilityPath: string, capabilityId: string): P
 	for (const entry of entries) {
 		if (entry.isFile() && entry.name.endsWith(".md")) {
 			const rulePath = join(rulesDir, entry.name);
-			const content = await Bun.file(rulePath).text();
+			const content = await readFile(rulePath, "utf-8");
 
 			rules.push({
 				name: basename(entry.name, ".md"),
@@ -51,7 +52,7 @@ export async function writeRules(rules: Rule[], docs: Doc[] = []): Promise<void>
 	// Read existing content or create new file
 	let content: string;
 	if (existsSync(instructionsPath)) {
-		content = await Bun.file(instructionsPath).text();
+		content = await readFile(instructionsPath, "utf-8");
 	} else {
 		// Create new file with basic template
 		content = `# OmniDev Instructions
@@ -85,7 +86,7 @@ export async function writeRules(rules: Rule[], docs: Doc[] = []): Promise<void>
 			content.substring(endIndex);
 	}
 
-	await Bun.write(instructionsPath, content);
+	await writeFile(instructionsPath, content, "utf-8");
 }
 
 function generateRulesContent(rules: Rule[], docs: Doc[] = []): string {

package/src/capability/skills.ts

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { Skill } from "../types";
 import { parseFrontmatterWithMarkdown } from "./yaml-parser";
@@ -34,7 +35,7 @@ export async function loadSkills(capabilityPath: string, capabilityId: string):
 }
 
 async function parseSkillFile(filePath: string, capabilityId: string): Promise<Skill> {
-	const content = await Bun.file(filePath).text();
+	const content = await readFile(filePath, "utf-8");
 
 	const parsed = parseFrontmatterWithMarkdown<SkillFrontmatter>(content);
 

package/src/capability/sources.ts

@@ -9,6 +9,7 @@
  */
 
 import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
 import { cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseToml } from "smol-toml";
@@ -53,6 +54,37 @@ export interface SourceUpdateInfo {
 	hasUpdate: boolean;
 }
 
+async function spawnCapture(
+	command: string,
+	args: string[],
+	options?: { cwd?: string },
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+	return await new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd: options?.cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+
+		let stdout = "";
+		let stderr = "";
+
+		child.stdout?.setEncoding("utf-8");
+		child.stderr?.setEncoding("utf-8");
+
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += chunk;
+		});
+
+		child.on("error", (error) => reject(error));
+		child.on("close", (exitCode) => {
+			resolve({ exitCode: exitCode ?? 0, stdout, stderr });
+		});
+	});
+}
+
 /**
  * Check if a source string is a git source
  */
@@ -188,14 +220,13 @@ export async function saveLockFile(lockFile: CapabilitiesLockFile): Promise<void
  * Get the current commit hash of a git repository
  */
 async function getRepoCommit(repoPath: string): Promise<string> {
-	const proc = Bun.spawn(["git", "rev-parse", "HEAD"], {
+	const { exitCode, stdout, stderr } = await spawnCapture("git", ["rev-parse", "HEAD"], {
 		cwd: repoPath,
-		stdout: "pipe",
-		stderr: "pipe",
 	});
-	const output = await new Response(proc.stdout).text();
-	await proc.exited;
-	return output.trim();
+	if (exitCode !== 0) {
+		throw new Error(`Failed to get commit for ${repoPath}: ${stderr.trim()}`);
+	}
+	return stdout.trim();
 }
 
 /**
@@ -218,16 +249,9 @@ async function cloneRepo(gitUrl: string, targetPath: string, ref?: string): Prom
 	}
 	args.push(gitUrl, targetPath);
 
-	const proc = Bun.spawn(["git", ...args], {
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-
-	await proc.exited;
-
-	if (proc.exitCode !== 0) {
-		const stderr = await new Response(proc.stderr).text();
-		throw new Error(`Failed to clone ${gitUrl}: ${stderr}`);
+	const { exitCode, stderr } = await spawnCapture("git", args);
+	if (exitCode !== 0) {
+		throw new Error(`Failed to clone ${gitUrl}: ${stderr.trim()}`);
 	}
 }
 
@@ -236,39 +260,36 @@ async function cloneRepo(gitUrl: string, targetPath: string, ref?: string): Prom
  */
 async function fetchRepo(repoPath: string, ref?: string): Promise<boolean> {
 	// Fetch latest
-	const fetchProc = Bun.spawn(["git", "fetch", "--depth", "1", "origin"], {
+	const fetchResult = await spawnCapture("git", ["fetch", "--depth", "1", "origin"], {
 		cwd: repoPath,
-		stdout: "pipe",
-		stderr: "pipe",
 	});
-	await fetchProc.exited;
+	if (fetchResult.exitCode !== 0) {
+		throw new Error(`Failed to fetch in ${repoPath}: ${fetchResult.stderr.trim()}`);
+	}
 
 	// Get current and remote commits
 	const currentCommit = await getRepoCommit(repoPath);
 
 	// Check remote commit
 	const targetRef = ref || "HEAD";
-	const lsProc = Bun.spawn(["git", "ls-remote", "origin", targetRef], {
+	const lsResult = await spawnCapture("git", ["ls-remote", "origin", targetRef], {
 		cwd: repoPath,
-		stdout: "pipe",
-		stderr: "pipe",
 	});
-	const lsOutput = await new Response(lsProc.stdout).text();
-	await lsProc.exited;
+	if (lsResult.exitCode !== 0) {
+		throw new Error(`Failed to ls-remote in ${repoPath}: ${lsResult.stderr.trim()}`);
+	}
 
-	const remoteCommit = lsOutput.split("\t")[0];
+	const remoteCommit = lsResult.stdout.split("\t")[0];
 
 	if (currentCommit === remoteCommit) {
 		return false; // No update
 	}
 
 	// Pull changes
-	const pullProc = Bun.spawn(["git", "pull", "--ff-only"], {
-		cwd: repoPath,
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-	await pullProc.exited;
+	const pullResult = await spawnCapture("git", ["pull", "--ff-only"], { cwd: repoPath });
+	if (pullResult.exitCode !== 0) {
+		throw new Error(`Failed to pull in ${repoPath}: ${pullResult.stderr.trim()}`);
+	}
 
 	return true; // Updated
 }
@@ -965,24 +986,23 @@ export async function checkForUpdates(config: OmniConfig): Promise<SourceUpdateI
 		}
 
 		// Fetch to check for updates (without pulling)
-		const fetchProc = Bun.spawn(["git", "fetch", "--depth", "1", "origin"], {
+		const fetchResult = await spawnCapture("git", ["fetch", "--depth", "1", "origin"], {
 			cwd: targetPath,
-			stdout: "pipe",
-			stderr: "pipe",
 		});
-		await fetchProc.exited;
+		if (fetchResult.exitCode !== 0) {
+			throw new Error(`Failed to fetch in ${targetPath}: ${fetchResult.stderr.trim()}`);
+		}
 
 		// Get remote commit
 		const targetRef = gitConfig.ref || "HEAD";
-		const lsProc = Bun.spawn(["git", "ls-remote", "origin", targetRef], {
+		const lsResult = await spawnCapture("git", ["ls-remote", "origin", targetRef], {
 			cwd: targetPath,
-			stdout: "pipe",
-			stderr: "pipe",
 		});
-		const lsOutput = await new Response(lsProc.stdout).text();
-		await lsProc.exited;
+		if (lsResult.exitCode !== 0) {
+			throw new Error(`Failed to ls-remote in ${targetPath}: ${lsResult.stderr.trim()}`);
+		}
 
-		const remoteCommit = lsOutput.split("\t")[0] || "";
+		const remoteCommit = lsResult.stdout.split("\t")[0] || "";
 		const currentCommit = existing?.commit || "";
 
 		updates.push({

package/src/capability/subagents.ts

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { Subagent, SubagentHooks, SubagentModel, SubagentPermissionMode } from "../types";
 import { parseFrontmatterWithMarkdown } from "./yaml-parser";
@@ -47,7 +48,7 @@ export async function loadSubagents(
 }
 
 async function parseSubagentFile(filePath: string, capabilityId: string): Promise<Subagent> {
-	const content = await Bun.file(filePath).text();
+	const content = await readFile(filePath, "utf-8");
 
 	const parsed = parseFrontmatterWithMarkdown<SubagentFrontmatter>(content);
 

package/src/config/env.ts

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import type { EnvDeclaration } from "../types";
 
 const ENV_FILE = ".omni/.env";
@@ -14,7 +15,7 @@ export async function loadEnvironment(): Promise<Record<string, string>> {
 
 	// Load from .omni/.env
 	if (existsSync(ENV_FILE)) {
-		const content = await Bun.file(ENV_FILE).text();
+		const content = await readFile(ENV_FILE, "utf-8");
 		for (const line of content.split("\n")) {
 			const trimmed = line.trim();
 			// Skip empty lines and comments

package/src/config/loader.ts

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import type { OmniConfig } from "../types";
 import { parseOmniConfig } from "./parser";
 
@@ -46,12 +47,12 @@ export async function loadConfig(): Promise<OmniConfig> {
 	let localConfig: OmniConfig = {};
 
 	if (existsSync(CONFIG_PATH)) {
-		const content = await Bun.file(CONFIG_PATH).text();
+		const content = await readFile(CONFIG_PATH, "utf-8");
 		baseConfig = parseOmniConfig(content);
 	}
 
 	if (existsSync(LOCAL_CONFIG)) {
-		const content = await Bun.file(LOCAL_CONFIG).text();
+		const content = await readFile(LOCAL_CONFIG, "utf-8");
 		localConfig = parseOmniConfig(content);
 	}
 
@@ -64,7 +65,7 @@ export async function loadConfig(): Promise<OmniConfig> {
  */
 export async function writeConfig(config: OmniConfig): Promise<void> {
 	const content = generateConfigToml(config);
-	await Bun.write(CONFIG_PATH, content);
+	await writeFile(CONFIG_PATH, content, "utf-8");
 }
 
 /**

package/src/config/provider.ts

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import { parse } from "smol-toml";
 import type { Provider, ProviderConfig } from "../types/index.js";
 
@@ -9,7 +10,7 @@ export async function loadProviderConfig(): Promise<ProviderConfig> {
 		return { provider: "claude" };
 	}
 
-	const content = await Bun.file(PROVIDER_CONFIG_PATH).text();
+	const content = await readFile(PROVIDER_CONFIG_PATH, "utf-8");
 	const parsed = parse(content) as unknown as ProviderConfig;
 	return parsed;
 }
@@ -40,7 +41,7 @@ export async function writeProviderConfig(config: ProviderConfig): Promise<void>
 		lines.push('provider = "claude"');
 	}
 
-	await Bun.write(PROVIDER_CONFIG_PATH, `${lines.join("\n")}\n`);
+	await writeFile(PROVIDER_CONFIG_PATH, `${lines.join("\n")}\n`, "utf-8");
 }
 
 export function parseProviderFlag(flag: string): Provider[] {

package/src/mcp-json/manager.ts

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import type { LoadedCapability, McpConfig } from "../types";
 import type { ResourceManifest } from "../state/manifest";
 
@@ -29,7 +30,7 @@ export async function readMcpJson(): Promise<McpJsonConfig> {
 	}
 
 	try {
-		const content = await Bun.file(MCP_JSON_PATH).text();
+		const content = await readFile(MCP_JSON_PATH, "utf-8");
 		const parsed = JSON.parse(content);
 		return {
 			mcpServers: parsed.mcpServers || {},
@@ -44,7 +45,7 @@ export async function readMcpJson(): Promise<McpJsonConfig> {
  * Write .mcp.json, preserving non-OmniDev entries
  */
 export async function writeMcpJson(config: McpJsonConfig): Promise<void> {
-	await Bun.write(MCP_JSON_PATH, JSON.stringify(config, null, 2));
+	await writeFile(MCP_JSON_PATH, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
 }
 
 /**

package/src/state/active-profile.ts

@@ -1,4 +1,5 @@
 import { existsSync, mkdirSync } from "node:fs";
+import { readFile, unlink, writeFile } from "node:fs/promises";
 
 const STATE_DIR = ".omni/state";
 const ACTIVE_PROFILE_PATH = `${STATE_DIR}/active-profile`;
@@ -13,7 +14,7 @@ export async function readActiveProfileState(): Promise<string | null> {
 	}
 
 	try {
-		const content = await Bun.file(ACTIVE_PROFILE_PATH).text();
+		const content = await readFile(ACTIVE_PROFILE_PATH, "utf-8");
 		const trimmed = content.trim();
 		return trimmed || null;
 	} catch {
@@ -27,7 +28,7 @@ export async function readActiveProfileState(): Promise<string | null> {
  */
 export async function writeActiveProfileState(profileName: string): Promise<void> {
 	mkdirSync(STATE_DIR, { recursive: true });
-	await Bun.write(ACTIVE_PROFILE_PATH, profileName);
+	await writeFile(ACTIVE_PROFILE_PATH, profileName, "utf-8");
 }
 
 /**
@@ -35,7 +36,6 @@ export async function writeActiveProfileState(profileName: string): Promise<void
  */
 export async function clearActiveProfileState(): Promise<void> {
 	if (existsSync(ACTIVE_PROFILE_PATH)) {
-		const file = Bun.file(ACTIVE_PROFILE_PATH);
-		await file.delete();
+		await unlink(ACTIVE_PROFILE_PATH);
 	}
 }

package/src/state/manifest.ts

@@ -1,4 +1,5 @@
 import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import type { LoadedCapability } from "../types";
 
 /**
@@ -52,7 +53,7 @@ export async function loadManifest(): Promise<ResourceManifest> {
 		};
 	}
 
-	const content = await Bun.file(MANIFEST_PATH).text();
+	const content = await readFile(MANIFEST_PATH, "utf-8");
 	return JSON.parse(content) as ResourceManifest;
 }
 
@@ -61,7 +62,7 @@ export async function loadManifest(): Promise<ResourceManifest> {
  */
 export async function saveManifest(manifest: ResourceManifest): Promise<void> {
 	mkdirSync(".omni/state", { recursive: true });
-	await Bun.write(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+	await writeFile(MANIFEST_PATH, `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
 }
 
 /**

package/src/state/providers.ts

@@ -1,4 +1,5 @@
 import { existsSync, mkdirSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import type { ProviderId } from "../types/index.js";
 
 const STATE_DIR = ".omni/state";
@@ -20,7 +21,7 @@ export async function readEnabledProviders(): Promise<ProviderId[]> {
 	}
 
 	try {
-		const content = await Bun.file(PROVIDERS_PATH).text();
+		const content = await readFile(PROVIDERS_PATH, "utf-8");
 		const state = JSON.parse(content) as ProvidersState;
 		return state.enabled.length > 0 ? state.enabled : DEFAULT_PROVIDERS;
 	} catch {
@@ -35,7 +36,7 @@ export async function readEnabledProviders(): Promise<ProviderId[]> {
 export async function writeEnabledProviders(providers: ProviderId[]): Promise<void> {
 	mkdirSync(STATE_DIR, { recursive: true });
 	const state: ProvidersState = { enabled: providers };
-	await Bun.write(PROVIDERS_PATH, JSON.stringify(state, null, 2));
+	await writeFile(PROVIDERS_PATH, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
 }
 
 /**

package/src/sync.ts

@@ -43,6 +43,23 @@ export async function installCapabilityDependencies(silent: boolean): Promise<vo
 
 	const entries = readdirSync(capabilitiesDir, { withFileTypes: true });
 
+	async function commandExists(cmd: string): Promise<boolean> {
+		return await new Promise((resolve) => {
+			const proc = spawn(cmd, ["--version"], { stdio: "ignore" });
+			proc.on("error", () => resolve(false));
+			proc.on("close", (code) => resolve(code === 0));
+		});
+	}
+
+	const hasBun = await commandExists("bun");
+	const hasNpm = hasBun ? false : await commandExists("npm");
+
+	if (!hasBun && !hasNpm) {
+		throw new Error(
+			"Neither Bun nor npm is installed. Install one of them to install capability dependencies.",
+		);
+	}
+
 	for (const entry of entries) {
 		if (!entry.isDirectory()) {
 			continue;
@@ -60,9 +77,13 @@ export async function installCapabilityDependencies(silent: boolean): Promise<vo
 			console.log(`Installing dependencies for ${capabilityPath}...`);
 		}
 
-		// Run bun install in the capability directory
+		// Prefer Bun if available, otherwise fallback to npm.
 		await new Promise<void>((resolve, reject) => {
-			const proc = spawn("bun", ["install"], {
+			const useNpmCi = hasNpm && existsSync(join(capabilityPath, "package-lock.json"));
+			const cmd = hasBun ? "bun" : "npm";
+			const args = hasBun ? ["install"] : useNpmCi ? ["ci"] : ["install"];
+
+			const proc = spawn(cmd, args, {
 				cwd: capabilityPath,
 				stdio: silent ? "ignore" : "inherit",
 			});