oneagent 0.2.4 → 0.2.6

package/dist/index.js

@@ -1290,6 +1290,59 @@ var init_dist3 = __esm(() => {
   zt = { light: C("─", "-"), heavy: C("━", "="), block: C("█", "#") };
   Qt = `${import_picocolors2.default.gray(d)}  `;
 });
+// ../core/src/agents.ts
+var AGENT_DEFINITIONS;
+var init_agents = __esm(() => {
+  AGENT_DEFINITIONS = [
+    {
+      target: "claude",
+      displayName: "Claude Code",
+      hint: "CLAUDE.md + .claude/rules/",
+      detectIndicators: ["CLAUDE.md", ".claude"],
+      mainFile: "CLAUDE.md",
+      rulesDir: ".claude/rules",
+      skillsDir: ".claude/skills"
+    },
+    {
+      target: "cursor",
+      displayName: "Cursor",
+      hint: "AGENTS.md + .cursor/rules/",
+      detectIndicators: [".cursor", ".cursorrules"],
+      mainFile: "AGENTS.md",
+      rulesDir: ".cursor/rules",
+      skillsDir: ".cursor/skills",
+      deprecatedFiles: [".cursorrules"]
+    },
+    {
+      target: "windsurf",
+      displayName: "Windsurf",
+      hint: "AGENTS.md + .windsurf/rules/",
+      detectIndicators: [".windsurf", ".windsurfrules"],
+      mainFile: "AGENTS.md",
+      rulesDir: ".windsurf/rules",
+      skillsDir: ".windsurf/skills",
+      deprecatedFiles: [".windsurfrules"]
+    },
+    {
+      target: "opencode",
+      displayName: "OpenCode",
+      hint: "AGENTS.md + .opencode/",
+      detectIndicators: ["opencode.json", ".opencode"],
+      mainFile: "AGENTS.md",
+      rulesDir: ".opencode/rules",
+      skillsDir: ".opencode/skills"
+    },
+    {
+      target: "copilot",
+      displayName: "GitHub Copilot",
+      hint: ".github/instructions/*.instructions.md",
+      detectIndicators: [".github/copilot-instructions.md", ".github"],
+      mainFile: ".github/copilot-instructions.md",
+      skillsDir: ".github/skills"
+    }
+  ];
+});
+
 // ../../node_modules/.bun/yaml@2.8.2/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS((exports) => {
   var ALIAS = Symbol.for("yaml.alias");
@@ -8324,6 +8377,7 @@ async function detectDeprecatedCommandFiles(root) {
 }
 var AGENT_FILES, DEPRECATED_FILES;
 var init_detect = __esm(() => {
+  init_agents();
   AGENT_FILES = [
     "CLAUDE.md",
     "AGENTS.md",
@@ -8331,7 +8385,7 @@ var init_detect = __esm(() => {
     ".windsurfrules",
     ".github/copilot-instructions.md"
   ];
-  DEPRECATED_FILES = [".cursorrules"];
+  DEPRECATED_FILES = AGENT_DEFINITIONS.flatMap((d2) => d2.deprecatedFiles ?? []);
 });
 
 // ../core/src/rules.ts
@@ -8411,7 +8465,7 @@ async function ensureDir(dirPath) {
 async function createSymlink(symlinkPath, target) {
   await ensureDir(path5.dirname(symlinkPath));
   try {
-    await fs5.unlink(symlinkPath);
+    await fs5.rm(symlinkPath, { recursive: true });
   } catch {}
   await fs5.symlink(target, symlinkPath);
 }
@@ -8422,24 +8476,8 @@ function buildMainSymlinks(root, targets) {
   const instructionsAbs = path5.join(root, ".oneagent/instructions.md");
   const seen = new Map;
   for (const target of targets) {
-    let symlinkPath;
-    switch (target) {
-      case "claude":
-        symlinkPath = path5.join(root, "CLAUDE.md");
-        break;
-      case "cursor":
-        symlinkPath = path5.join(root, "AGENTS.md");
-        break;
-      case "windsurf":
-        symlinkPath = path5.join(root, ".windsurfrules");
-        break;
-      case "opencode":
-        symlinkPath = path5.join(root, "AGENTS.md");
-        break;
-      case "copilot":
-        symlinkPath = path5.join(root, ".github/copilot-instructions.md");
-        break;
-    }
+    const def = AGENT_DEFINITIONS.find((d2) => d2.target === target);
+    const symlinkPath = path5.join(root, def.mainFile);
     if (!seen.has(symlinkPath)) {
       seen.set(symlinkPath, {
         symlinkPath,
@@ -8450,51 +8488,19 @@ function buildMainSymlinks(root, targets) {
   }
   return Array.from(seen.values());
 }
-function buildRulesSymlinks(root, targets, rules) {
-  const entries = [];
-  for (const target of targets) {
-    let rulesDir = null;
-    switch (target) {
-      case "claude":
-        rulesDir = path5.join(root, ".claude/rules");
-        break;
-      case "cursor":
-        rulesDir = path5.join(root, ".cursor/rules");
-        break;
-      case "windsurf":
-        rulesDir = path5.join(root, ".windsurf/rules");
-        break;
-      case "opencode":
-      case "copilot":
-        rulesDir = null;
-        break;
-    }
-    if (!rulesDir)
-      continue;
-    for (const rule of rules) {
-      const symlinkPath = path5.join(rulesDir, `${rule.name}.md`);
-      entries.push({
-        symlinkPath,
-        target: relativeTarget(symlinkPath, rule.path),
-        label: path5.relative(root, symlinkPath)
-      });
-    }
-  }
-  return entries;
+function buildRulesSymlinks(root, targets) {
+  const targetAbs = path5.join(root, ".oneagent/rules");
+  return AGENT_DEFINITIONS.filter((d2) => targets.includes(d2.target) && d2.rulesDir).map((d2) => {
+    const symlinkPath = path5.join(root, d2.rulesDir);
+    return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d2.rulesDir };
+  });
 }
 function buildSkillSymlinks(root, targets) {
   const targetAbs = path5.join(root, ".oneagent/skills");
-  const agentDirs = {
-    claude: path5.join(root, ".claude/skills"),
-    cursor: path5.join(root, ".cursor/skills"),
-    windsurf: path5.join(root, ".windsurf/skills"),
-    copilot: path5.join(root, ".github/skills")
-  };
-  return Object.entries(agentDirs).filter(([target]) => targets.includes(target)).map(([, dir]) => ({
-    symlinkPath: dir,
-    target: relativeTarget(dir, targetAbs),
-    label: path5.relative(root, dir)
-  }));
+  return AGENT_DEFINITIONS.filter((d2) => targets.includes(d2.target) && d2.skillsDir).map((d2) => {
+    const symlinkPath = path5.join(root, d2.skillsDir);
+    return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d2.skillsDir };
+  });
 }
 function buildAgentsDirSymlinks(root) {
   const symlinkPath = path5.join(root, ".agents/skills");
@@ -8551,9 +8557,10 @@ async function migrateAndRemoveDir(src, dest, root) {
 async function migrateRuleAndSkillFiles(root) {
   const destRules = path5.join(root, ".oneagent/rules");
   const destSkills = path5.join(root, ".oneagent/skills");
-  await migrateFilesFromDir(path5.join(root, ".cursor/rules"), destRules, root);
-  await migrateFilesFromDir(path5.join(root, ".claude/rules"), destRules, root);
-  await migrateFilesFromDir(path5.join(root, ".windsurf/rules"), destRules, root);
+  await migrateAndRemoveDir(path5.join(root, ".cursor/rules"), destRules, root);
+  await migrateAndRemoveDir(path5.join(root, ".claude/rules"), destRules, root);
+  await migrateAndRemoveDir(path5.join(root, ".windsurf/rules"), destRules, root);
+  await migrateAndRemoveDir(path5.join(root, ".opencode/rules"), destRules, root);
   await migrateAndRemoveDir(path5.join(root, ".agents/skills"), destSkills, root);
 }
 async function createAllSymlinks(entries) {
@@ -8571,7 +8578,9 @@ async function checkSymlink(entry) {
     return { ...entry, exists: false, valid: false };
   }
 }
-var init_symlinks = () => {};
+var init_symlinks = __esm(() => {
+  init_agents();
+});
 
 // ../core/src/copilot.ts
 import path6 from "path";
@@ -8631,6 +8640,21 @@ function buildOpencodeConfig(existing) {
     instructions: ".oneagent/instructions.md"
   };
 }
+async function addOpenCodePlugin(root, id) {
+  const filePath = path7.join(root, "opencode.json");
+  let existing;
+  try {
+    existing = JSON.parse(await fs7.readFile(filePath, "utf-8"));
+  } catch {
+    return;
+  }
+  const current = Array.isArray(existing.plugin) ? existing.plugin : [];
+  if (current.includes(id))
+    return;
+  existing.plugin = [...current, id];
+  await fs7.writeFile(filePath, JSON.stringify(existing, null, 2) + `
+`);
+}
 async function writeOpencode(root, _rules) {
   const existing = await readOpencode(root);
   const config = buildOpencodeConfig(existing);
@@ -8647,7 +8671,7 @@ async function detectGenerateCollisions(root, config) {
   const targets = activeTargets(config);
   const mainEntries = buildMainSymlinks(root, targets);
   const ruleSkillEntries = [
-    ...buildRulesSymlinks(root, targets, rules),
+    ...buildRulesSymlinks(root, targets),
     ...buildSkillSymlinks(root, targets)
   ];
   const [mainCollisions, ruleSkillSymlinkCollisions] = await Promise.all([
@@ -8694,7 +8718,7 @@ async function generate(root, config) {
   const targets = activeTargets(config);
   await migrateRuleAndSkillFiles(root);
   const mainSymlinks = buildMainSymlinks(root, targets);
-  const rulesSymlinks = buildRulesSymlinks(root, targets, rules);
+  const rulesSymlinks = buildRulesSymlinks(root, targets);
   const skillSymlinks = await buildSkillSymlinks(root, targets);
   await createAllSymlinks([...mainSymlinks, ...rulesSymlinks, ...skillSymlinks, ...buildAgentsDirSymlinks(root)]);
   if (targets.includes("copilot")) {
@@ -8747,7 +8771,7 @@ async function checkStatus(root, config) {
   const targets = activeTargets(config);
   const allEntries = [
     ...buildMainSymlinks(root, targets),
-    ...buildRulesSymlinks(root, targets, rules),
+    ...buildRulesSymlinks(root, targets),
     ...buildSkillSymlinks(root, targets),
     ...buildAgentsDirSymlinks(root)
   ];
@@ -8773,6 +8797,25 @@ import path9 from "path";
 import fs10 from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
+function parsePluginsFromYaml(yamlText) {
+  const plugins = [];
+  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(),
+        id: idMatch[1].trim()
+      });
+    }
+  }
+  return plugins;
+}
 async function applyTemplateFiles(root, template) {
   const oneagentDir = path9.join(root, ".oneagent");
   await fs10.mkdir(path9.join(oneagentDir, "rules"), { recursive: true });
@@ -8793,6 +8836,37 @@ async function installTemplateSkills(root, template, onSkillInstalled) {
     }
   }
 }
+async function installTemplatePlugins(root, template, activeTargets2, onPluginInstalled) {
+  const installed = [];
+  const manual = [];
+  for (const plugin of template.plugins) {
+    if (!activeTargets2.includes(plugin.target))
+      continue;
+    switch (plugin.target) {
+      case "claude":
+        await execFileAsync("claude", ["plugin", "install", plugin.id], { cwd: root });
+        installed.push(plugin);
+        onPluginInstalled?.(plugin);
+        break;
+      case "copilot":
+        await execFileAsync("copilot", ["plugin", "install", plugin.id], { cwd: root });
+        installed.push(plugin);
+        onPluginInstalled?.(plugin);
+        break;
+      case "opencode":
+        await addOpenCodePlugin(root, plugin.id);
+        installed.push(plugin);
+        onPluginInstalled?.(plugin);
+        break;
+      case "cursor":
+        manual.push(plugin);
+        break;
+      case "windsurf":
+        break;
+    }
+  }
+  return { installed, manual };
+}
 async function fetchTemplateFromGitHub(url) {
   const rawBase = githubUrlToRawBase(url);
   const [yamlText, instructions] = await Promise.all([
@@ -8814,8 +8888,9 @@ async function fetchTemplateFromGitHub(url) {
         skills.push(skill);
     }
   }
+  const plugins = parsePluginsFromYaml(yamlText);
   const rules = await fetchGitHubRules(url);
-  return { name, description, skills, instructions, rules };
+  return { name, description, skills, plugins, instructions, rules };
 }
 async function fetchText(url) {
   const response = await fetch(url);
@@ -8857,11 +8932,13 @@ async function fetchGitHubRules(repoUrl) {
 }
 var execFileAsync;
 var init_apply_template = __esm(() => {
+  init_opencode();
   execFileAsync = promisify(execFile);
 });
 
 // ../core/src/index.ts
 var init_src = __esm(() => {
+  init_agents();
   init_config();
   init_detect();
   init_rules();
@@ -8930,6 +9007,7 @@ async function loadTemplate(name) {
         skills2.push(skill);
     }
   }
+  const plugins = parsePluginsFromYaml(yamlText);
   const rulesDir = path10.join(templateDir, "rules");
   let rules2 = [];
   try {
@@ -8939,7 +9017,7 @@ async function loadTemplate(name) {
       content: await fs11.readFile(path10.join(rulesDir, f), "utf-8")
     })));
   } catch {}
-  return { name, description, skills: skills2, instructions, rules: rules2 };
+  return { name, description, skills: skills2, plugins, instructions, rules: rules2 };
 }
 async function resolveBuiltinTemplate(name) {
   if (!TEMPLATE_NAMES.includes(name))
@@ -8948,6 +9026,7 @@ async function resolveBuiltinTemplate(name) {
 }
 var __dirname2, TEMPLATE_NAMES, BUILTIN_TEMPLATE_NAMES;
 var init_src2 = __esm(() => {
+  init_src();
   __dirname2 = path10.dirname(fileURLToPath(import.meta.url));
   TEMPLATE_NAMES = ["default", "react", "react-native"];
   BUILTIN_TEMPLATE_NAMES = TEMPLATE_NAMES;
@@ -9011,18 +9090,24 @@ async function chooseContent(detected) {
   const index = parseInt(result.replace("file:", ""), 10);
   return detected[index].content;
 }
-async function pickTargets() {
+async function detectPresentTargets(root) {
+  const results = await Promise.all(AGENT_DEFINITIONS.map(async (def) => {
+    for (const indicator of def.detectIndicators) {
+      try {
+        await fs12.access(path11.join(root, indicator));
+        return def.target;
+      } catch {}
+    }
+    return null;
+  }));
+  return results.filter((t) => t !== null);
+}
+async function pickTargets(initialValues) {
   const result = await je({
     message: `Which AI agents do you want to support?
 \x1B[90m · Space to toggle · Enter to confirm\x1B[39m`,
-    options: [
-      { value: "claude", label: "Claude Code", hint: "CLAUDE.md + .claude/rules/" },
-      { value: "cursor", label: "Cursor", hint: "AGENTS.md + .cursor/rules/" },
-      { value: "windsurf", label: "Windsurf", hint: ".windsurfrules + .windsurf/rules/" },
-      { value: "opencode", label: "OpenCode", hint: "AGENTS.md + opencode.json" },
-      { value: "copilot", label: "GitHub Copilot", hint: ".github/instructions/*.instructions.md" }
-    ],
-    initialValues: ["claude"],
+    options: AGENT_DEFINITIONS.map((d2) => ({ value: d2.target, label: d2.displayName, hint: d2.hint })),
+    initialValues,
     required: true
   });
   if (Ct(result))
@@ -9113,14 +9198,14 @@ var init_init = __esm(() => {
       } else {
         importedContent = await chooseContent(detected);
       }
-      const selectedTargets = await pickTargets();
+      const presentTargets = await detectPresentTargets(root);
+      const selectedTargets = await pickTargets(presentTargets);
       const s = bt2();
       s.start("Setting up .oneagent/ directory...");
       await fs12.mkdir(path11.join(root, ".oneagent/rules"), { recursive: true });
       await fs12.mkdir(path11.join(root, ".oneagent/skills"), { recursive: true });
       await backupFiles(root, detected);
       await removeDeprecatedFiles(root);
-      await warnDeprecatedCommandFiles(root);
       await migrateRuleAndSkillFiles(root);
       const config2 = { version: 1, targets: makeTargets(...selectedTargets) };
       await writeConfig(root, config2);
@@ -9135,6 +9220,7 @@ Add your AI instructions here.
       }
       await fs12.writeFile(path11.join(root, ".oneagent/rules/oneagent.md"), DOTAI_META_RULE);
       s.stop("Directory structure created.");
+      await warnDeprecatedCommandFiles(root);
       const s2 = bt2();
       s2.start("Generating symlinks and agent files...");
       await generate(root, config2);
@@ -9146,11 +9232,20 @@ Add your AI instructions here.
         await installTemplateSkills(root, template, (id) => fetchedSkills.push(id));
         s3.stop(`Installed ${fetchedSkills.length} skill(s).`);
       }
+      let pluginResult = { installed: [], manual: [] };
+      if (template && template.plugins.length > 0) {
+        const s4 = bt2();
+        s4.start("Installing plugins...");
+        pluginResult = await installTemplatePlugins(root, template, selectedTargets);
+        s4.stop(`Installed ${pluginResult.installed.length} plugin(s).`);
+      }
       const lines = [
         ...template ? [
           `Template: ${template.name} — ${template.description}`,
           ...fetchedSkills.length > 0 ? [`Fetched ${fetchedSkills.length} skill(s): ${fetchedSkills.join(", ")}`] : [],
-          ...template.rules.length > 0 ? [`Added ${template.rules.length} rule(s) from template`] : []
+          ...template.rules.length > 0 ? [`Added ${template.rules.length} rule(s) from template`] : [],
+          ...pluginResult.installed.length > 0 ? [`Installed ${pluginResult.installed.length} plugin(s): ${pluginResult.installed.map((p) => p.id).join(", ")}`] : [],
+          ...pluginResult.manual.map((p) => `Run in Cursor chat: /add-plugin ${p.id}`)
         ] : ["Created .oneagent/instructions.md"],
         "Created .oneagent/rules/oneagent.md",
         ...selectedTargets.map((t) => `Configured: ${t}`),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oneagent",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "description": "One source of truth for AI agent rules — distributed via symlinks to Claude, Cursor, Windsurf, Copilot, OpenCode",
   "license": "MIT",