@moskala/oneagent-core 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moskala/oneagent-core",
-  "version": "0.2.4",
+  "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

@@ -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/",
+    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",
+    // 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

@@ -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/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",
@@ -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,7 +22,7 @@ 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),
+    ...buildRulesSymlinks(root, targets),
     ...buildSkillSymlinks(root, targets),
     // .agents/skills skipped — handled by migrateAgentsSkillsDir
   ];
@@ -73,7 +73,7 @@ export async function generate(root: string, config: Config): Promise<void> {
   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)]);
 

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

@@ -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/status.ts

@@ -44,7 +44,7 @@ export async function checkStatus(root: string, config: Config): Promise<StatusR
 
   const allEntries = [
     ...buildMainSymlinks(root, targets),
-    ...buildRulesSymlinks(root, targets, rules),
+    ...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, 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 });
@@ -9,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);
 }
@@ -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,64 +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! };
+    });
 }
 
-// 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),
-    }));
+  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[] {
@@ -179,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);
 }