@moskala/oneagent-core 0.2.3 → 0.2.5

package/package.json

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

package/src/agents.ts

@@ -0,0 +1,71 @@
+import type { AgentTarget } from "./types.ts";
+
+export interface AgentDefinition {
+  target: AgentTarget;
+  displayName: string;
+  hint: string;
+  /** Paths (relative to root) checked to detect agent presence. Any match = present. */
+  detectIndicators: string[];
+  /** Symlink path for main instructions file (relative to root). */
+  mainFile: string;
+  /** Whole-dir symlink for rules (relative to root). Omit if not applicable. */
+  rulesDir?: string;
+  /** Whole-dir symlink for skills (relative to root). Omit if not applicable. */
+  skillsDir?: string;
+  /** Legacy files to remove during init (superseded by current format). */
+  deprecatedFiles?: string[];
+}
+
+export const AGENT_DEFINITIONS: AgentDefinition[] = [
+  {
+    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",
+    // rules: handled via opencode.json config, not symlinks
+    // skills: handled via .agents/skills dir symlink
+  },
+  {
+    target: "copilot",
+    displayName: "GitHub Copilot",
+    hint: ".github/instructions/*.instructions.md",
+    detectIndicators: [".github/copilot-instructions.md", ".github"],
+    mainFile: ".github/copilot-instructions.md",
+    skillsDir: ".github/skills",
+    // rules: generated as .instructions.md files, not symlinks
+  },
+];
+
+export function getAgentDef(target: AgentTarget): AgentDefinition {
+  return AGENT_DEFINITIONS.find((d) => d.target === target)!;
+}

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

@@ -1,6 +1,7 @@
 import path from "path";
 import fs from "fs/promises";
 import type { DetectedFile } from "./types.ts";
+import { AGENT_DEFINITIONS } from "./agents.ts";
 
 export const AGENT_FILES = [
   "CLAUDE.md",
@@ -22,7 +23,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,
@@ -46,7 +47,7 @@ export function filesHaveSameContent(files: DetectedFile[]): boolean {
   return files.every((f) => f.content === first);
 }
 
-const DEPRECATED_FILES = [".cursorrules"];
+const DEPRECATED_FILES = AGENT_DEFINITIONS.flatMap((d) => d.deprecatedFiles ?? []);
 
 export async function removeDeprecatedFiles(root: string): Promise<void> {
   for (const rel of DEPRECATED_FILES) {

package/src/generate.ts

@@ -22,8 +22,8 @@ export async function detectGenerateCollisions(root: string, config: Config): Pr
   const mainEntries = buildMainSymlinks(root, targets);
   // 2. Rule/skill symlink paths
   const ruleSkillEntries = [
-    ...buildRulesSymlinks(root, targets, rules),
-    ...buildSkillSymlinks(root, targets, skills),
+    ...buildRulesSymlinks(root, targets),
+    ...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);
 
-  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")) {

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./types.ts";
+export * from "./agents.ts";
 export * from "./config.ts";
 export * from "./detect.ts";
 export * from "./rules.ts";

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 };
@@ -43,8 +44,8 @@ export async function checkStatus(root: string, config: Config): Promise<StatusR
 
   const allEntries = [
     ...buildMainSymlinks(root, targets),
-    ...buildRulesSymlinks(root, targets, rules),
-    ...buildSkillSymlinks(root, targets, skills),
+    ...buildRulesSymlinks(root, targets),
+    ...buildSkillSymlinks(root, targets),
     ...buildAgentsDirSymlinks(root),
   ];
 

package/src/symlinks.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import fs from "fs/promises";
-import type { AgentTarget, RuleFile, SkillFile, SymlinkCheck, SymlinkEntry } from "./types.ts";
+import type { AgentTarget, SymlinkCheck, SymlinkEntry } from "./types.ts";
+import { AGENT_DEFINITIONS } from "./agents.ts";
 
 export async function ensureDir(dirPath: string): Promise<void> {
   await fs.mkdir(dirPath, { recursive: true });
@@ -25,26 +26,8 @@ export function buildMainSymlinks(root: string, targets: AgentTarget[]): Symlink
   const seen = new Map<string, SymlinkEntry>();
 
   for (const target of targets) {
-    let symlinkPath: string;
-
-    switch (target) {
-      case "claude":
-        symlinkPath = path.join(root, "CLAUDE.md");
-        break;
-      case "cursor":
-        symlinkPath = path.join(root, "AGENTS.md");
-        break;
-      case "windsurf":
-        symlinkPath = path.join(root, ".windsurfrules");
-        break;
-      case "opencode":
-        symlinkPath = path.join(root, "AGENTS.md");
-        break;
-      case "copilot":
-        symlinkPath = path.join(root, ".github/copilot-instructions.md");
-        break;
-    }
-
+    const def = AGENT_DEFINITIONS.find((d) => d.target === target)!;
+    const symlinkPath = path.join(root, def.mainFile);
     if (!seen.has(symlinkPath)) {
       seen.set(symlinkPath, {
         symlinkPath,
@@ -57,59 +40,24 @@ export function buildMainSymlinks(root: string, targets: AgentTarget[]): Symlink
   return Array.from(seen.values());
 }
 
-export function buildRulesSymlinks(
-  root: string,
-  targets: AgentTarget[],
-  rules: RuleFile[],
-): SymlinkEntry[] {
-  const entries: SymlinkEntry[] = [];
-
-  for (const target of targets) {
-    let rulesDir: string | null = null;
-
-    switch (target) {
-      case "claude":
-        rulesDir = path.join(root, ".claude/rules");
-        break;
-      case "cursor":
-        rulesDir = path.join(root, ".cursor/rules");
-        break;
-      case "windsurf":
-        rulesDir = path.join(root, ".windsurf/rules");
-        break;
-      case "opencode":
-      case "copilot":
-        rulesDir = null;
-        break;
-    }
-
-    if (!rulesDir) continue;
-
-    for (const rule of rules) {
-      const symlinkPath = path.join(rulesDir, `${rule.name}.md`);
-      entries.push({
-        symlinkPath,
-        target: relativeTarget(symlinkPath, rule.path),
-        label: path.relative(root, symlinkPath),
-      });
-    }
-  }
-
-  return entries;
+export function buildRulesSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[] {
+  const targetAbs = path.join(root, ".oneagent/rules");
+  return AGENT_DEFINITIONS
+    .filter((d) => targets.includes(d.target) && d.rulesDir)
+    .map((d) => {
+      const symlinkPath = path.join(root, d.rulesDir!);
+      return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d.rulesDir! };
+    });
 }
 
-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),
-    };
-  });
+export function buildSkillSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[] {
+  const targetAbs = path.join(root, ".oneagent/skills");
+  return AGENT_DEFINITIONS
+    .filter((d) => targets.includes(d.target) && d.skillsDir)
+    .map((d) => {
+      const symlinkPath = path.join(root, d.skillsDir!);
+      return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d.skillsDir! };
+    });
 }
 
 export function buildAgentsDirSymlinks(root: string): SymlinkEntry[] {
@@ -142,15 +90,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 {