@moskala/oneagent-core 0.2.5 → 0.3.0

package/package.json

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

package/src/agents.ts

@@ -12,6 +12,8 @@ export interface AgentDefinition {
   rulesDir?: string;
   /** Whole-dir symlink for skills (relative to root). Omit if not applicable. */
   skillsDir?: string;
+  /** Whole-dir symlink for commands (relative to root). Omit if agent does not support custom commands. */
+  commandsDir?: string;
   /** Legacy files to remove during init (superseded by current format). */
   deprecatedFiles?: string[];
 }
@@ -25,6 +27,7 @@ export const AGENT_DEFINITIONS: AgentDefinition[] = [
     mainFile: "CLAUDE.md",
     rulesDir: ".claude/rules",
     skillsDir: ".claude/skills",
+    commandsDir: ".claude/commands",
   },
   {
     target: "cursor",
@@ -35,6 +38,7 @@ export const AGENT_DEFINITIONS: AgentDefinition[] = [
     rulesDir: ".cursor/rules",
     skillsDir: ".cursor/skills",
     deprecatedFiles: [".cursorrules"],
+    commandsDir: ".cursor/commands",
   },
   {
     target: "windsurf",
@@ -49,11 +53,12 @@ export const AGENT_DEFINITIONS: AgentDefinition[] = [
   {
     target: "opencode",
     displayName: "OpenCode",
-    hint: "AGENTS.md + opencode.json",
+    hint: "AGENTS.md + .opencode/",
     detectIndicators: ["opencode.json", ".opencode"],
     mainFile: "AGENTS.md",
-    // rules: handled via opencode.json config, not symlinks
-    // skills: handled via .agents/skills dir symlink
+    rulesDir: ".opencode/rules",
+    skillsDir: ".opencode/skills",
+    commandsDir: ".opencode/commands",
   },
   {
     target: "copilot",
@@ -62,7 +67,7 @@ export const AGENT_DEFINITIONS: AgentDefinition[] = [
     detectIndicators: [".github/copilot-instructions.md", ".github"],
     mainFile: ".github/copilot-instructions.md",
     skillsDir: ".github/skills",
-    // rules: generated as .instructions.md files, not symlinks
+    // rules: generated as <name>.instructions.md files, not symlinks
   },
 ];
 

package/src/apply-template.ts

@@ -2,17 +2,90 @@ import path from "path";
 import fs from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
+import type { AgentTarget } from "./types.ts";
+import { addOpenCodePlugin } from "./opencode.ts";
 
 const execFileAsync = promisify(execFile);
 
+export interface TemplatePlugin {
+  target: AgentTarget;
+  id: string;
+}
+
+export interface SkillEntry {
+  repo: string;
+  skill: string;
+}
+
 export interface TemplateDefinition {
   name: string;
   description: string;
-  skills: string[];
+  skills: SkillEntry[];
+  plugins: TemplatePlugin[];
   instructions: string;
   rules: Array<{ name: string; content: string }>;
 }
 
+// Parses name, description, skills and plugins from a template.yml string.
+// This is the single source of truth for the template.yml format — used by
+// both builtin template loading and GitHub URL template fetching.
+export function parseTemplateYaml(yamlText: string, fallbackName = "custom"): Pick<TemplateDefinition, "name" | "description" | "skills" | "plugins"> {
+  const nameMatch = yamlText.match(/^name:\s*(.+)$/m);
+  const name = nameMatch?.[1]?.trim() ?? fallbackName;
+
+  const descMatch = yamlText.match(/^description:\s*(.+)$/m);
+  const description = descMatch?.[1]?.trim() ?? "";
+
+  const skills = parseSkillsFromYaml(yamlText);
+  const plugins = parsePluginsFromYaml(yamlText);
+  return { name, description, skills, plugins };
+}
+
+// Parses the `skills:` block from a template.yml string.
+// Expects entries in the format:
+//   skills:
+//     - repo: https://github.com/owner/skills
+//       skill: skill-name
+export function parseSkillsFromYaml(yamlText: string): SkillEntry[] {
+  const skills: SkillEntry[] = [];
+  const section = yamlText.match(/^skills:\s*\n((?:(?:  -.+|\s{4}.+)\n?)*)/m);
+  if (!section) return skills;
+  const block = section[1]!;
+  const entries = block.split(/\n(?=  -)/);
+  for (const entry of entries) {
+    const repoMatch = entry.match(/repo:\s*(\S+)/);
+    const skillMatch = entry.match(/skill:\s*(\S+)/);
+    if (repoMatch && skillMatch) {
+      skills.push({ repo: repoMatch[1]!.trim(), skill: skillMatch[1]!.trim() });
+    }
+  }
+  return skills;
+}
+
+// Parses the `plugins:` block from a template.yml string.
+// Expects entries in the format:
+//   plugins:
+//     - target: claude
+//       id: typescript-lsp@claude-plugins-official
+export function parsePluginsFromYaml(yamlText: string): TemplatePlugin[] {
+  const plugins: TemplatePlugin[] = [];
+  const section = yamlText.match(/^plugins:\s*\n((?:(?:  -.+|\s{4}.+)\n?)*)/m);
+  if (!section) return plugins;
+  const block = section[1]!;
+  const entries = block.split(/\n(?=  -)/);
+  for (const entry of entries) {
+    const targetMatch = entry.match(/target:\s*(\S+)/);
+    const idMatch = entry.match(/id:\s*(.+)/);
+    if (targetMatch && idMatch) {
+      plugins.push({
+        target: targetMatch[1]!.trim() as AgentTarget,
+        id: idMatch[1]!.trim(),
+      });
+    }
+  }
+  return plugins;
+}
+
 // Phase 1: writes instructions.md and rules/*.md.
 // Call this BEFORE generate() so symlinks to rules are created.
 export async function applyTemplateFiles(root: string, template: TemplateDefinition): Promise<void> {
@@ -28,22 +101,93 @@ export async function applyTemplateFiles(root: string, template: TemplateDefinit
   }
 }
 
-// Phase 2: installs skills via `bunx skills add <identifier> --yes`.
-// Call this AFTER generate() so agent directories (symlinks) already exist.
+export interface SkillInstallResult {
+  installed: SkillEntry[];
+  failed: Array<{ entry: SkillEntry; reason: string }>;
+}
+
+// Phase 2: installs skills via `npx skills add <repo> --skill <name>`.
+// All skills are installed in parallel. Call this AFTER generate() so agent directories exist.
+// Never throws — failed skills are collected and returned in the result.
 export async function installTemplateSkills(
   root: string,
   template: TemplateDefinition,
-  onSkillInstalled?: (identifier: string) => void,
-): Promise<void> {
-  for (const identifier of template.skills) {
+): Promise<SkillInstallResult> {
+  const results = await Promise.all(
+    template.skills.map(async (entry) => {
+      try {
+        await execFileAsync("npx", ["skills", "add", entry.repo, "--skill", entry.skill, "--agent", "universal", "--yes"], { cwd: root });
+        return { entry, ok: true as const };
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        return { entry, ok: false as const, reason };
+      }
+    }),
+  );
+
+  return {
+    installed: results.filter((r) => r.ok).map((r) => r.entry),
+    failed: results.filter((r) => !r.ok).map((r) => ({ entry: r.entry, reason: (r as { reason: string }).reason })),
+  };
+}
+
+export interface PluginInstallResult {
+  installed: TemplatePlugin[];
+  manual: TemplatePlugin[];
+  failed: Array<{ plugin: TemplatePlugin; reason: string }>;
+}
+
+// Phase 3: installs plugins for active targets. Call AFTER generate().
+// - claude  → `claude plugin install <id>`
+// - copilot → `copilot plugin install <id>`
+// - opencode → adds id to plugin[] in opencode.json
+// - cursor  → added to manual list (no CLI yet — user runs /add-plugin in chat)
+// - windsurf → skipped (no marketplace)
+// Never throws — failed plugins are collected and returned in the result.
+export async function installTemplatePlugins(
+  root: string,
+  template: TemplateDefinition,
+  activeTargets: AgentTarget[],
+): Promise<PluginInstallResult> {
+  const installed: TemplatePlugin[] = [];
+  const manual: TemplatePlugin[] = [];
+  const failed: Array<{ plugin: TemplatePlugin; reason: string }> = [];
+
+  for (const plugin of template.plugins) {
+    if (!activeTargets.includes(plugin.target)) continue;
+
     try {
-      await execFileAsync("npx", ["skills", "add", identifier, "--agent", "universal", "--yes"], { cwd: root });
-      onSkillInstalled?.(identifier);
+      switch (plugin.target) {
+        case "claude":
+          await execFileAsync("claude", ["plugin", "install", plugin.id], { cwd: root });
+          installed.push(plugin);
+          break;
+
+        case "copilot":
+          await execFileAsync("copilot", ["plugin", "install", plugin.id], { cwd: root });
+          installed.push(plugin);
+          break;
+
+        case "opencode":
+          await addOpenCodePlugin(root, plugin.id);
+          installed.push(plugin);
+          break;
+
+        case "cursor":
+          manual.push(plugin);
+          break;
+
+        case "windsurf":
+          // No marketplace yet — skip silently
+          break;
+      }
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new Error(`Failed to install skill "${identifier}": ${message}`);
+      const reason = err instanceof Error ? err.message : String(err);
+      failed.push({ plugin, reason });
     }
   }
+
+  return { installed, manual, failed };
 }
 
 // Fetches a template from a GitHub URL.
@@ -58,26 +202,12 @@ export async function fetchTemplateFromGitHub(url: string): Promise<TemplateDefi
     fetchText(`${rawBase}/instructions.md`),
   ]);
 
-  const descMatch = yamlText.match(/^description:\s*(.+)$/m);
-  const description = descMatch?.[1]?.trim() ?? "";
-
-  const nameMatch = yamlText.match(/^name:\s*(.+)$/m);
-  const name = nameMatch?.[1]?.trim() ?? "custom";
-
-  const skills: string[] = [];
-  const skillsBlockMatch = yamlText.match(/^skills:\s*\n((?:  - .+\n?)*)/m);
-  if (skillsBlockMatch) {
-    const lines = skillsBlockMatch[1]!.split("\n").filter(Boolean);
-    for (const line of lines) {
-      const skill = line.replace(/^\s*-\s*/, "").trim();
-      if (skill) skills.push(skill);
-    }
-  }
+  const { name, description, skills, plugins } = parseTemplateYaml(yamlText);
 
   // Try to list rules via GitHub API
   const rules = await fetchGitHubRules(url);
 
-  return { name, description, skills, instructions, rules };
+  return { name, description, skills, plugins, instructions, rules };
 }
 
 async function fetchText(url: string): Promise<string> {
@@ -88,23 +218,36 @@ async function fetchText(url: string): Promise<string> {
   return response.text();
 }
 
-function githubUrlToRawBase(url: string): string {
-  // Handle https://github.com/owner/repo/tree/branch or https://github.com/owner/repo
-  const match = url.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+))?(?:\/.*)?$/);
+interface GitHubUrlParts {
+  owner: string;
+  repo: string;
+  branch: string;
+  subdir: string; // "" for root, "path/to/dir" for subdirectories
+}
+
+function parseGitHubUrl(url: string): GitHubUrlParts {
+  // Supports:
+  //   https://github.com/owner/repo
+  //   https://github.com/owner/repo/tree/branch
+  //   https://github.com/owner/repo/tree/branch/path/to/subdir
+  const match = url.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+?)(?:\/(.+))?)?(?:\/)?$/);
   if (!match) {
     throw new Error(`Invalid GitHub URL: "${url}". Expected format: https://github.com/owner/repo`);
   }
-  const [, owner, repo, branch = "main"] = match;
-  return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
+  const [, owner, repo, branch = "main", subdir = ""] = match;
+  return { owner: owner!, repo: repo!, branch, subdir };
 }
 
-async function fetchGitHubRules(repoUrl: string): Promise<Array<{ name: string; content: string }>> {
-  // Parse owner/repo from URL
-  const match = repoUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+))?(?:\/.*)?$/);
-  if (!match) return [];
-  const [, owner, repo, branch = "main"] = match;
+function githubUrlToRawBase(url: string): string {
+  const { owner, repo, branch, subdir } = parseGitHubUrl(url);
+  const base = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
+  return subdir ? `${base}/${subdir}` : base;
+}
 
-  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/rules?ref=${branch}`;
+async function fetchGitHubRules(repoUrl: string): Promise<Array<{ name: string; content: string }>> {
+  const { owner, repo, branch, subdir } = parseGitHubUrl(repoUrl);
+  const rulesPath = subdir ? `${subdir}/rules` : "rules";
+  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${rulesPath}?ref=${branch}`;
   try {
     const response = await fetch(apiUrl, {
       headers: { Accept: "application/vnd.github.v3+json" },

package/src/commands.ts

@@ -0,0 +1,16 @@
+import path from "path";
+import fs from "fs/promises";
+import type { CommandFile } from "./types.ts";
+
+export async function readCommands(root: string): Promise<CommandFile[]> {
+  const commandsDir = path.join(root, ".oneagent/commands");
+  try {
+    const files = await fs.readdir(commandsDir);
+    return files
+      .filter((f) => f.endsWith(".md"))
+      .map((f) => ({ name: path.basename(f, ".md"), path: path.join(commandsDir, f) }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}

package/src/copilot.ts

@@ -2,18 +2,14 @@ import path from "path";
 import fs from "fs/promises";
 import type { RuleFile, SkillFile } from "./types.ts";
 
-export function buildCopilotContent(rule: RuleFile): string {
-  return `---\napplyTo: "${rule.applyTo}"\n---\n${rule.content}`;
-}
-
 export function copilotFilePath(root: string, ruleName: string): string {
   return path.join(root, ".github/instructions", `${ruleName}.instructions.md`);
 }
 
 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 fs.writeFile(filePath, buildCopilotContent(rule));
+  const destPath = copilotFilePath(root, rule.name);
+  await fs.mkdir(path.dirname(destPath), { recursive: true });
+  await fs.copyFile(rule.path, destPath);
 }
 
 export async function generateCopilotRules(root: string, rules: RuleFile[]): Promise<void> {

package/src/detect.ts

@@ -61,14 +61,3 @@ export async function removeDeprecatedFiles(root: string): Promise<void> {
   }
 }
 
-export async function detectDeprecatedCommandFiles(root: string): Promise<string[]> {
-  const commandsDir = path.join(root, ".claude/commands");
-  try {
-    const entries = await fs.readdir(commandsDir, { withFileTypes: true });
-    return entries
-      .filter((e) => e.isFile())
-      .map((e) => path.join(".claude/commands", e.name));
-  } catch {
-    return [];
-  }
-}

package/src/generate.ts

@@ -4,8 +4,8 @@ import type { Config, DetectedFile } from "./types.ts";
 import { activeTargets } from "./config.ts";
 import { readRules } from "./rules.ts";
 import { readSkills } from "./skills.ts";
-import { buildMainSymlinks, buildRulesSymlinks, buildSkillSymlinks, buildAgentsDirSymlinks, createAllSymlinks, migrateRuleAndSkillFiles } from "./symlinks.ts";
-import { buildCopilotContent, copilotFilePath, buildCopilotPromptContent, copilotPromptFilePath, generateCopilotRules, generateCopilotSkills } from "./copilot.ts";
+import { buildMainSymlinks, buildRulesSymlinks, buildSkillSymlinks, buildCommandSymlinks, buildAgentsDirSymlinks, createAllSymlinks, migrateRuleAndSkillFiles } from "./symlinks.ts";
+import { copilotFilePath, buildCopilotPromptContent, copilotPromptFilePath, generateCopilotRules, generateCopilotSkills } from "./copilot.ts";
 import { writeOpencode } from "./opencode.ts";
 import { readDetectedFile } from "./detect.ts";
 
@@ -24,6 +24,7 @@ export async function detectGenerateCollisions(root: string, config: Config): Pr
   const ruleSkillEntries = [
     ...buildRulesSymlinks(root, targets),
     ...buildSkillSymlinks(root, targets),
+    ...buildCommandSymlinks(root, targets),
     // .agents/skills skipped — handled by migrateAgentsSkillsDir
   ];
 
@@ -41,10 +42,13 @@ 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 fs.readFile(filePath, "utf-8");
-          if (content === buildCopilotContent(rule)) return null;
+          const [source, dest] = await Promise.all([
+            fs.readFile(rule.path, "utf-8"),
+            fs.readFile(filePath, "utf-8"),
+          ]);
+          if (source === dest) return null;
           const stat = await fs.lstat(filePath);
-          return { relativePath: path.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content };
+          return { relativePath: path.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content: dest };
         } catch { return null; }
       }),
       ...skills.map(async (skill): Promise<DetectedFile | null> => {
@@ -75,7 +79,8 @@ export async function generate(root: string, config: Config): Promise<void> {
   const mainSymlinks = buildMainSymlinks(root, targets);
   const rulesSymlinks = buildRulesSymlinks(root, targets);
   const skillSymlinks = await buildSkillSymlinks(root, targets);
-  await createAllSymlinks([...mainSymlinks, ...rulesSymlinks, ...skillSymlinks, ...buildAgentsDirSymlinks(root)]);
+  const commandSymlinks = buildCommandSymlinks(root, targets);
+  await createAllSymlinks([...mainSymlinks, ...rulesSymlinks, ...skillSymlinks, ...commandSymlinks, ...buildAgentsDirSymlinks(root)]);
 
   if (targets.includes("copilot")) {
     await Promise.all([generateCopilotRules(root, rules), generateCopilotSkills(root, skills)]);

package/src/index.ts

@@ -3,6 +3,7 @@ export * from "./agents.ts";
 export * from "./config.ts";
 export * from "./detect.ts";
 export * from "./rules.ts";
+export * from "./commands.ts";
 export * from "./skills.ts";
 export * from "./symlinks.ts";
 export * from "./copilot.ts";

package/src/opencode.ts

@@ -18,6 +18,20 @@ export function buildOpencodeConfig(existing: Record<string, unknown> | null): o
   };
 }
 
+export async function addOpenCodePlugin(root: string, id: string): Promise<void> {
+  const filePath = path.join(root, "opencode.json");
+  let existing: Record<string, unknown>;
+  try {
+    existing = JSON.parse(await fs.readFile(filePath, "utf-8")) as Record<string, unknown>;
+  } catch {
+    return; // no opencode.json — no-op
+  }
+  const current = Array.isArray(existing.plugin) ? (existing.plugin as string[]) : [];
+  if (current.includes(id)) return;
+  existing.plugin = [...current, id];
+  await fs.writeFile(filePath, JSON.stringify(existing, null, 2) + "\n");
+}
+
 export async function writeOpencode(root: string, _rules: RuleFile[]): Promise<void> {
   const existing = await readOpencode(root);
   const config = buildOpencodeConfig(existing);

package/src/rules.ts

@@ -2,32 +2,14 @@ import path from "path";
 import fs from "fs/promises";
 import type { RuleFile } from "./types.ts";
 
-export function parseFrontmatter(raw: string): { applyTo: string; content: string } {
-  const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
-  if (!match) return { applyTo: "**", content: raw };
-
-  const frontmatter = match[1] ?? "";
-  const content = match[2] ?? "";
-
-  const applyToMatch = frontmatter.match(/applyTo:\s*["']?([^"'\n]+)["']?/);
-  const applyTo = applyToMatch?.[1]?.trim() ?? "**";
-
-  return { applyTo, content };
-}
-
-export async function readRuleFile(filePath: string): Promise<RuleFile> {
-  const raw = await fs.readFile(filePath, "utf-8");
-  const { applyTo, content } = parseFrontmatter(raw);
-  return { name: path.basename(filePath, ".md"), path: filePath, applyTo, content };
-}
-
 export async function readRules(root: string): Promise<RuleFile[]> {
   const rulesDir = path.join(root, ".oneagent/rules");
   try {
     const files = await fs.readdir(rulesDir);
-    const mdFiles = files.filter((f) => f.endsWith(".md"));
-    const rules = await Promise.all(mdFiles.map((f) => readRuleFile(path.join(rulesDir, f))));
-    return rules.sort((a, b) => a.name.localeCompare(b.name));
+    return files
+      .filter((f) => f.endsWith(".md"))
+      .map((f) => ({ name: path.basename(f, ".md"), path: path.join(rulesDir, f) }))
+      .sort((a, b) => a.name.localeCompare(b.name));
   } catch {
     return [];
   }

package/src/status.ts

@@ -3,16 +3,18 @@ import type { Config, GeneratedFileCheck, OpenCodeCheck, RuleFile, StatusResult
 import { activeTargets } from "./config.ts";
 import { readRules } from "./rules.ts";
 import { readSkills } from "./skills.ts";
-import { buildMainSymlinks, buildRulesSymlinks, buildSkillSymlinks, buildAgentsDirSymlinks, checkSymlink } from "./symlinks.ts";
-import { buildCopilotContent, buildCopilotPromptContent, copilotFilePath, copilotPromptFilePath } from "./copilot.ts";
+import { buildMainSymlinks, buildRulesSymlinks, buildSkillSymlinks, buildCommandSymlinks, buildAgentsDirSymlinks, checkSymlink } from "./symlinks.ts";
+import { buildCopilotPromptContent, copilotFilePath, copilotPromptFilePath } from "./copilot.ts";
 import { readOpencode } from "./opencode.ts";
 
 export async function checkGeneratedFile(root: string, rule: RuleFile): Promise<GeneratedFileCheck> {
   const filePath = copilotFilePath(root, rule.name);
-  const expected = buildCopilotContent(rule);
   try {
-    const content = await fs.readFile(filePath, "utf-8");
-    return { path: filePath, exists: true, upToDate: content === expected };
+    const [source, dest] = await Promise.all([
+      fs.readFile(rule.path, "utf-8"),
+      fs.readFile(filePath, "utf-8"),
+    ]);
+    return { path: filePath, exists: true, upToDate: source === dest };
   } catch {
     return { path: filePath, exists: false, upToDate: false };
   }
@@ -46,6 +48,7 @@ export async function checkStatus(root: string, config: Config): Promise<StatusR
     ...buildMainSymlinks(root, targets),
     ...buildRulesSymlinks(root, targets),
     ...buildSkillSymlinks(root, targets),
+    ...buildCommandSymlinks(root, targets),
     ...buildAgentsDirSymlinks(root),
   ];
 

package/src/symlinks.ts

@@ -10,9 +10,9 @@ export async function ensureDir(dirPath: string): Promise<void> {
 export async function createSymlink(symlinkPath: string, target: string): Promise<void> {
   await ensureDir(path.dirname(symlinkPath));
   try {
-    await fs.unlink(symlinkPath);
+    await fs.rm(symlinkPath, { recursive: true });
   } catch {
-    // file doesn't exist — that's fine
+    // doesn't exist — that's fine
   }
   await fs.symlink(target, symlinkPath);
 }
@@ -60,6 +60,16 @@ export function buildSkillSymlinks(root: string, targets: AgentTarget[]): Symlin
     });
 }
 
+export function buildCommandSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[] {
+  const targetAbs = path.join(root, ".oneagent/commands");
+  return AGENT_DEFINITIONS
+    .filter((d) => targets.includes(d.target) && d.commandsDir)
+    .map((d) => {
+      const symlinkPath = path.join(root, d.commandsDir!);
+      return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d.commandsDir! };
+    });
+}
+
 export function buildAgentsDirSymlinks(root: string): SymlinkEntry[] {
   const symlinkPath = path.join(root, ".agents/skills");
   const targetAbs = path.join(root, ".oneagent/skills");
@@ -122,19 +132,22 @@ async function migrateAndRemoveDir(src: string, dest: string, root: string): Pro
 export async function migrateRuleAndSkillFiles(root: string): Promise<void> {
   const destRules = path.join(root, ".oneagent/rules");
   const destSkills = path.join(root, ".oneagent/skills");
-  // Rules dirs: only individual files become symlinks, so we only move the files.
-  // The directories themselves stay — generate() recreates per-file symlinks inside them.
-  // Sequential to avoid same-name conflicts across dirs.
-  await migrateFilesFromDir(path.join(root, ".cursor/rules"), destRules, root);
-  await migrateFilesFromDir(path.join(root, ".claude/rules"), destRules, root);
-  await migrateFilesFromDir(path.join(root, ".windsurf/rules"), destRules, root);
-  // .agents/skills is different: the entire directory becomes a symlink to .oneagent/skills,
-  // so the real directory must be removed first to make room for the symlink.
+  const destCommands = path.join(root, ".oneagent/commands");
+  // Derive migration sources from agent definitions — sequential to avoid same-name conflicts.
+  for (const def of AGENT_DEFINITIONS) {
+    if (def.rulesDir) await migrateAndRemoveDir(path.join(root, def.rulesDir), destRules, root);
+  }
+  // .agents/skills — standard skills.sh path, not represented in agent definitions
   await migrateAndRemoveDir(path.join(root, ".agents/skills"), destSkills, root);
+  for (const def of AGENT_DEFINITIONS) {
+    if (def.commandsDir) await migrateAndRemoveDir(path.join(root, def.commandsDir), destCommands, root);
+  }
 }
 
 export async function createAllSymlinks(entries: SymlinkEntry[]): Promise<void> {
-  await Promise.all(entries.map((e) => createSymlink(e.symlinkPath, e.target)));
+  for (const e of entries) {
+    await createSymlink(e.symlinkPath, e.target);
+  }
 }
 
 export async function checkSymlink(entry: SymlinkEntry): Promise<SymlinkCheck> {

package/src/types.ts

@@ -16,8 +16,11 @@ export interface DetectedFile {
 export interface RuleFile {
   name: string;
   path: string;
-  applyTo: string;
-  content: string;
+}
+
+export interface CommandFile {
+  name: string;
+  path: string;
 }
 
 export interface SkillFile {