@moskala/oneagent-core 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moskala/oneagent-core",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "type": "module",
   "description": "Core library for oneagent — one source of truth for AI agent rules",
   "license": "MIT",

package/src/apply-template.ts

@@ -1,5 +1,9 @@
 import path from "path";
 import fs from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+const execFileAsync = promisify(execFile);
 
 export interface TemplateDefinition {
   name: string;
@@ -17,10 +21,10 @@ export async function applyTemplateFiles(root: string, template: TemplateDefinit
   await fs.mkdir(path.join(oneagentDir, "rules"), { recursive: true });
   await fs.mkdir(path.join(oneagentDir, "skills"), { recursive: true });
 
-  await Bun.write(path.join(oneagentDir, "instructions.md"), template.instructions);
+  await fs.writeFile(path.join(oneagentDir, "instructions.md"), template.instructions);
 
   for (const rule of template.rules) {
-    await Bun.write(path.join(oneagentDir, "rules", `${rule.name}.md`), rule.content);
+    await fs.writeFile(path.join(oneagentDir, "rules", `${rule.name}.md`), rule.content);
   }
 }
 
@@ -33,7 +37,7 @@ export async function installTemplateSkills(
 ): Promise<void> {
   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);

package/src/config.ts

@@ -1,5 +1,6 @@
 import { parse, stringify } from "yaml";
 import path from "path";
+import fs from "fs/promises";
 import type { AgentTarget, Config } from "./types.ts";
 
 const CONFIG_REL = ".oneagent/config.yml";
@@ -15,15 +16,16 @@ export function makeTargets(...enabled: AgentTarget[]): Record<AgentTarget, bool
 }
 
 export async function configExists(root: string): Promise<boolean> {
-  return Bun.file(path.join(root, CONFIG_REL)).exists();
+  return fs.access(path.join(root, CONFIG_REL)).then(() => true, () => false);
 }
 
 export async function readConfig(root: string): Promise<Config> {
-  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) as Config;
 }
 
 export async function writeConfig(root: string, config: Config): Promise<void> {
   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));
 }

package/src/copilot.ts

@@ -13,7 +13,7 @@ export function copilotFilePath(root: string, ruleName: string): string {
 export async function generateCopilotRule(root: string, rule: RuleFile): Promise<void> {
   const filePath = copilotFilePath(root, rule.name);
   await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await Bun.write(filePath, buildCopilotContent(rule));
+  await fs.writeFile(filePath, buildCopilotContent(rule));
 }
 
 export async function generateCopilotRules(root: string, rules: RuleFile[]): Promise<void> {
@@ -34,7 +34,7 @@ export function copilotPromptFilePath(root: string, skillName: string): string {
 export async function generateCopilotSkill(root: string, skill: SkillFile): Promise<void> {
   const filePath = copilotPromptFilePath(root, skill.name);
   await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await Bun.write(filePath, buildCopilotPromptContent(skill));
+  await fs.writeFile(filePath, buildCopilotPromptContent(skill));
 }
 
 export async function generateCopilotSkills(root: string, skills: SkillFile[]): Promise<void> {

package/src/detect.ts

@@ -22,7 +22,7 @@ export async function readDetectedFile(root: string, rel: string): Promise<Detec
       if (resolved.startsWith(path.join(root, ".one"))) return null;
     }
 
-    const content = await Bun.file(absolutePath).text();
+    const content = await fs.readFile(absolutePath, "utf-8");
     return {
       relativePath: rel,
       absolutePath,

package/src/generate.ts

@@ -23,7 +23,7 @@ export async function detectGenerateCollisions(root: string, config: Config): Pr
   // 2. Rule/skill symlink paths
   const ruleSkillEntries = [
     ...buildRulesSymlinks(root, targets, rules),
-    ...buildSkillSymlinks(root, targets, skills),
+    ...buildSkillSymlinks(root, targets),
     // .agents/skills skipped — handled by migrateAgentsSkillsDir
   ];
 
@@ -41,7 +41,7 @@ export async function detectGenerateCollisions(root: string, config: Config): Pr
       ...rules.map(async (rule): Promise<DetectedFile | null> => {
         const filePath = copilotFilePath(root, rule.name);
         try {
-          const content = await Bun.file(filePath).text();
+          const content = await fs.readFile(filePath, "utf-8");
           if (content === buildCopilotContent(rule)) return null;
           const stat = await fs.lstat(filePath);
           return { relativePath: path.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content };
@@ -50,7 +50,7 @@ export async function detectGenerateCollisions(root: string, config: Config): Pr
       ...skills.map(async (skill): Promise<DetectedFile | null> => {
         const filePath = copilotPromptFilePath(root, skill.name);
         try {
-          const content = await Bun.file(filePath).text();
+          const content = await fs.readFile(filePath, "utf-8");
           if (content === buildCopilotPromptContent(skill)) return null;
           const stat = await fs.lstat(filePath);
           return { relativePath: path.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content };
@@ -70,10 +70,11 @@ export async function generate(root: string, config: Config): Promise<void> {
   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")) {

package/src/opencode.ts

@@ -1,9 +1,10 @@
 import path from "path";
+import fs from "fs/promises";
 import type { RuleFile } from "./types.ts";
 
 export async function readOpencode(root: string): Promise<Record<string, unknown> | null> {
   try {
-    const content = await Bun.file(path.join(root, "opencode.json")).text();
+    const content = await fs.readFile(path.join(root, "opencode.json"), "utf-8");
     return JSON.parse(content) as Record<string, unknown>;
   } catch {
     return null;
@@ -20,5 +21,5 @@ export function buildOpencodeConfig(existing: Record<string, unknown> | null): o
 export async function writeOpencode(root: string, _rules: RuleFile[]): Promise<void> {
   const existing = await readOpencode(root);
   const config = buildOpencodeConfig(existing);
-  await Bun.write(path.join(root, "opencode.json"), JSON.stringify(config, null, 2) + "\n");
+  await fs.writeFile(path.join(root, "opencode.json"), JSON.stringify(config, null, 2) + "\n");
 }

package/src/rules.ts

@@ -16,7 +16,7 @@ export function parseFrontmatter(raw: string): { applyTo: string; content: strin
 }
 
 export async function readRuleFile(filePath: string): Promise<RuleFile> {
-  const raw = await Bun.file(filePath).text();
+  const raw = await fs.readFile(filePath, "utf-8");
   const { applyTo, content } = parseFrontmatter(raw);
   return { name: path.basename(filePath, ".md"), path: filePath, applyTo, content };
 }

package/src/skills.ts

@@ -23,7 +23,7 @@ export function parseSkillFrontmatter(raw: string): { description: string; mode:
 }
 
 export async function readSkillFile(filePath: string): Promise<SkillFile> {
-  const raw = await Bun.file(filePath).text();
+  const raw = await fs.readFile(filePath, "utf-8");
   const { description, mode, content } = parseSkillFrontmatter(raw);
   return { name: path.basename(filePath, ".md"), path: filePath, description, mode, content };
 }

package/src/status.ts

@@ -1,3 +1,4 @@
+import fs from "fs/promises";
 import type { Config, GeneratedFileCheck, OpenCodeCheck, RuleFile, StatusResult } from "./types.ts";
 import { activeTargets } from "./config.ts";
 import { readRules } from "./rules.ts";
@@ -10,7 +11,7 @@ export async function checkGeneratedFile(root: string, rule: RuleFile): Promise<
   const filePath = copilotFilePath(root, rule.name);
   const expected = buildCopilotContent(rule);
   try {
-    const content = await Bun.file(filePath).text();
+    const content = await fs.readFile(filePath, "utf-8");
     return { path: filePath, exists: true, upToDate: content === expected };
   } catch {
     return { path: filePath, exists: false, upToDate: false };
@@ -30,7 +31,7 @@ export async function checkCopilotPrompt(root: string, skill: import("./types.ts
   const filePath = copilotPromptFilePath(root, skill.name);
   const expected = buildCopilotPromptContent(skill);
   try {
-    const content = await Bun.file(filePath).text();
+    const content = await fs.readFile(filePath, "utf-8");
     return { path: filePath, exists: true, upToDate: content === expected };
   } catch {
     return { path: filePath, exists: false, upToDate: false };
@@ -44,7 +45,7 @@ export async function checkStatus(root: string, config: Config): Promise<StatusR
   const allEntries = [
     ...buildMainSymlinks(root, targets),
     ...buildRulesSymlinks(root, targets, rules),
-    ...buildSkillSymlinks(root, targets, skills),
+    ...buildSkillSymlinks(root, targets),
     ...buildAgentsDirSymlinks(root),
   ];
 

package/src/symlinks.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs/promises";
-import type { AgentTarget, RuleFile, SkillFile, SymlinkCheck, SymlinkEntry } from "./types.ts";
+import type { AgentTarget, RuleFile, SymlinkCheck, SymlinkEntry } from "./types.ts";
 
 export async function ensureDir(dirPath: string): Promise<void> {
   await fs.mkdir(dirPath, { recursive: true });
@@ -98,18 +98,23 @@ export function buildRulesSymlinks(
   return entries;
 }
 
-export function buildSkillSymlinks(root: string, targets: AgentTarget[], skills: SkillFile[]): SymlinkEntry[] {
-  if (!targets.includes("claude")) return [];
-
-  const commandsDir = path.join(root, ".claude/commands");
-  return skills.map((skill) => {
-    const symlinkPath = path.join(commandsDir, `${skill.name}.md`);
-    return {
-      symlinkPath,
-      target: relativeTarget(symlinkPath, skill.path),
-      label: path.relative(root, symlinkPath),
-    };
-  });
+// Creates whole-directory symlinks: .claude/skills → .oneagent/skills, .cursor/skills → .oneagent/skills
+export function buildSkillSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[] {
+  const targetAbs = path.join(root, ".oneagent/skills");
+  const agentDirs: Partial<Record<AgentTarget, string>> = {
+    claude: path.join(root, ".claude/skills"),
+    cursor: path.join(root, ".cursor/skills"),
+    windsurf: path.join(root, ".windsurf/skills"),
+    copilot: path.join(root, ".github/skills"),
+  };
+
+  return (Object.entries(agentDirs) as [AgentTarget, string][])
+    .filter(([target]) => targets.includes(target))
+    .map(([, dir]) => ({
+      symlinkPath: dir,
+      target: relativeTarget(dir, targetAbs),
+      label: path.relative(root, dir),
+    }));
 }
 
 export function buildAgentsDirSymlinks(root: string): SymlinkEntry[] {
@@ -142,15 +147,15 @@ async function migrateFilesFromDir(srcDir: string, destDir: string, root: string
     if (destExists) {
       // dest exists — compare content before deleting source
       const [srcContent, destContent] = await Promise.all([
-        Bun.file(srcFile).text(),
-        Bun.file(destFile).text(),
+        fs.readFile(srcFile, "utf-8"),
+        fs.readFile(destFile, "utf-8"),
       ]);
       if (srcContent !== destContent) {
         // Different content — backup source before deleting
         const backupDir = path.join(root, ".oneagent/backup");
         await fs.mkdir(backupDir, { recursive: true });
         const safeName = path.relative(root, srcFile).replace(/\//g, "_");
-        await Bun.write(path.join(backupDir, safeName), srcContent);
+        await fs.writeFile(path.join(backupDir, safeName), srcContent);
       }
       await fs.unlink(srcFile); // safe to delete — dest has the content (or backup was created)
     } else {