@moskala/oneagent-core 0.2.4 → 0.2.5

package/package.json

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