@moskala/oneagent-core 0.2.5 → 0.2.6

package/package.json

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

package/src/agents.ts

@@ -49,11 +49,11 @@ 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",
   },
   {
     target: "copilot",

package/src/apply-template.ts

@@ -2,17 +2,49 @@ 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 TemplateDefinition {
   name: string;
   description: string;
   skills: string[];
+  plugins: TemplatePlugin[];
   instructions: string;
   rules: Array<{ name: string; content: string }>;
 }
 
+// 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> {
@@ -46,6 +78,61 @@ export async function installTemplateSkills(
   }
 }
 
+export interface PluginInstallResult {
+  installed: TemplatePlugin[];
+  manual: TemplatePlugin[];
+}
+
+// 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)
+export async function installTemplatePlugins(
+  root: string,
+  template: TemplateDefinition,
+  activeTargets: AgentTarget[],
+  onPluginInstalled?: (plugin: TemplatePlugin) => void,
+): Promise<PluginInstallResult> {
+  const installed: TemplatePlugin[] = [];
+  const manual: TemplatePlugin[] = [];
+
+  for (const plugin of template.plugins) {
+    if (!activeTargets.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":
+        // No marketplace yet — skip silently
+        break;
+    }
+  }
+
+  return { installed, manual };
+}
+
 // Fetches a template from a GitHub URL.
 // Expects the repository to contain: template.yml, instructions.md, and optionally rules/*.md
 export async function fetchTemplateFromGitHub(url: string): Promise<TemplateDefinition> {
@@ -74,10 +161,12 @@ export async function fetchTemplateFromGitHub(url: string): Promise<TemplateDefi
     }
   }
 
+  const plugins = parsePluginsFromYaml(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> {

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/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);
 }
@@ -122,14 +122,12 @@ 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.
+  // Rules dirs: the entire directory becomes a symlink, so move files out and remove the dir.
   // 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.
+  await migrateAndRemoveDir(path.join(root, ".cursor/rules"), destRules, root);
+  await migrateAndRemoveDir(path.join(root, ".claude/rules"), destRules, root);
+  await migrateAndRemoveDir(path.join(root, ".windsurf/rules"), destRules, root);
+  await migrateAndRemoveDir(path.join(root, ".opencode/rules"), destRules, root);
   await migrateAndRemoveDir(path.join(root, ".agents/skills"), destSkills, root);
 }