@moskala/oneagent-core 0.4.5 → 0.4.6

package/dist/copilot.d.ts

@@ -1,8 +1,3 @@
-import type { RuleFile, SkillFile } from "./types.ts";
+import type { RuleFile, SymlinkEntry } from "./types.ts";
 export declare function copilotFilePath(root: string, ruleName: string): string;
-export declare function generateCopilotRule(root: string, rule: RuleFile): Promise<void>;
-export declare function generateCopilotRules(root: string, rules: RuleFile[]): Promise<void>;
-export declare function buildCopilotPromptContent(skill: SkillFile): string;
-export declare function copilotPromptFilePath(root: string, skillName: string): string;
-export declare function generateCopilotSkill(root: string, skill: SkillFile): Promise<void>;
-export declare function generateCopilotSkills(root: string, skills: SkillFile[]): Promise<void>;
+export declare function buildCopilotRulesSymlinks(root: string, rules: RuleFile[]): SymlinkEntry[];

package/dist/index.js

@@ -405,43 +405,23 @@ async function checkSymlink(entry) {
 }
 // src/copilot.ts
 import path7 from "path";
-import fs7 from "fs/promises";
 function copilotFilePath(root, ruleName) {
   return path7.join(root, ".github/instructions", `${ruleName}.instructions.md`);
 }
-async function generateCopilotRule(root, rule) {
-  const destPath = copilotFilePath(root, rule.name);
-  await fs7.mkdir(path7.dirname(destPath), { recursive: true });
-  await fs7.copyFile(rule.path, destPath);
-}
-async function generateCopilotRules(root, rules) {
-  await Promise.all(rules.map((rule) => generateCopilotRule(root, rule)));
-}
-function buildCopilotPromptContent(skill) {
-  const lines = ["---", `mode: "${skill.mode}"`];
-  if (skill.description)
-    lines.push(`description: "${skill.description}"`);
-  lines.push("---", skill.content);
-  return lines.join(`
-`);
-}
-function copilotPromptFilePath(root, skillName) {
-  return path7.join(root, ".github/prompts", `${skillName}.prompt.md`);
-}
-async function generateCopilotSkill(root, skill) {
-  const filePath = copilotPromptFilePath(root, skill.name);
-  await fs7.mkdir(path7.dirname(filePath), { recursive: true });
-  await fs7.writeFile(filePath, buildCopilotPromptContent(skill));
-}
-async function generateCopilotSkills(root, skills) {
-  await Promise.all(skills.map((skill) => generateCopilotSkill(root, skill)));
+function buildCopilotRulesSymlinks(root, rules) {
+  return rules.map((rule) => {
+    const symlinkPath = copilotFilePath(root, rule.name);
+    const targetAbs = path7.join(root, ONEAGENT_DIR, "rules", `${rule.name}.md`);
+    const target = path7.relative(path7.dirname(symlinkPath), targetAbs);
+    return { symlinkPath, target, label: path7.relative(root, symlinkPath) };
+  });
 }
 // src/opencode.ts
 import path8 from "path";
-import fs8 from "fs/promises";
+import fs7 from "fs/promises";
 async function readOpencode(root) {
   try {
-    const content = await fs8.readFile(path8.join(root, "opencode.json"), "utf-8");
+    const content = await fs7.readFile(path8.join(root, "opencode.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -457,7 +437,7 @@ async function addOpenCodePlugin(root, id) {
   const filePath = path8.join(root, "opencode.json");
   let existing;
   try {
-    existing = JSON.parse(await fs8.readFile(filePath, "utf-8"));
+    existing = JSON.parse(await fs7.readFile(filePath, "utf-8"));
   } catch {
     return;
   }
@@ -465,136 +445,75 @@ async function addOpenCodePlugin(root, id) {
   if (current.includes(id))
     return;
   existing.plugin = [...current, id];
-  await fs8.writeFile(filePath, JSON.stringify(existing, null, 2) + `
+  await fs7.writeFile(filePath, JSON.stringify(existing, null, 2) + `
 `);
 }
 async function writeOpencode(root, _rules) {
   const existing = await readOpencode(root);
   const config = buildOpencodeConfig(existing);
-  await fs8.writeFile(path8.join(root, "opencode.json"), JSON.stringify(config, null, 2) + `
+  await fs7.writeFile(path8.join(root, "opencode.json"), JSON.stringify(config, null, 2) + `
 `);
 }
 // src/generate.ts
 import path9 from "path";
-import fs9 from "fs/promises";
 async function detectGenerateCollisions(root, config) {
-  const [rules, skills] = await Promise.all([readRules(root), readSkills(root)]);
+  const rules = await readRules(root);
   const targets = activeTargets(config);
   const mainEntries = buildMainSymlinks(root, targets);
   const ruleSkillEntries = [
     ...buildRulesSymlinks(root, targets),
     ...buildSkillSymlinks(root, targets),
-    ...buildCommandSymlinks(root, targets)
+    ...buildCommandSymlinks(root, targets),
+    ...targets.includes("copilot") ? buildCopilotRulesSymlinks(root, rules) : []
   ];
-  const [mainCollisions, ruleSkillSymlinkCollisions] = await Promise.all([
+  const [mainCollisions, ruleSkillCollisions] = await Promise.all([
     Promise.all(mainEntries.map((entry) => readDetectedFile(root, path9.relative(root, entry.symlinkPath)))).then((files) => files.filter((f) => f !== null)),
     Promise.all(ruleSkillEntries.map((entry) => readDetectedFile(root, path9.relative(root, entry.symlinkPath)))).then((files) => files.filter((f) => f !== null))
   ]);
-  const copilotCollisions = [];
-  if (targets.includes("copilot")) {
-    const checks = await Promise.all([
-      ...rules.map(async (rule) => {
-        const filePath = copilotFilePath(root, rule.name);
-        try {
-          const [source, dest] = await Promise.all([
-            fs9.readFile(rule.path, "utf-8"),
-            fs9.readFile(filePath, "utf-8")
-          ]);
-          if (source === dest)
-            return null;
-          const stat = await fs9.lstat(filePath);
-          return { relativePath: path9.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content: dest };
-        } catch {
-          return null;
-        }
-      }),
-      ...skills.map(async (skill) => {
-        const filePath = copilotPromptFilePath(root, skill.name);
-        try {
-          const content = await fs9.readFile(filePath, "utf-8");
-          if (content === buildCopilotPromptContent(skill))
-            return null;
-          const stat = await fs9.lstat(filePath);
-          return { relativePath: path9.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content };
-        } catch {
-          return null;
-        }
-      })
-    ]);
-    copilotCollisions.push(...checks.filter((c) => c !== null));
-  }
   return {
     mainFiles: mainCollisions,
-    ruleSkillFiles: [...ruleSkillSymlinkCollisions, ...copilotCollisions]
+    ruleSkillFiles: ruleSkillCollisions
   };
 }
 async function generate(root, config) {
-  const [rules, skills] = await Promise.all([readRules(root), readSkills(root)]);
+  const rules = await readRules(root);
   const targets = activeTargets(config);
   await migrateRuleAndSkillFiles(root);
   const mainSymlinks = buildMainSymlinks(root, targets);
   const rulesSymlinks = buildRulesSymlinks(root, targets);
-  const skillSymlinks = await buildSkillSymlinks(root, targets);
+  const skillSymlinks = buildSkillSymlinks(root, targets);
   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)]);
-  }
+  const copilotRulesSymlinks = targets.includes("copilot") ? buildCopilotRulesSymlinks(root, rules) : [];
+  await createAllSymlinks([...mainSymlinks, ...rulesSymlinks, ...skillSymlinks, ...commandSymlinks, ...copilotRulesSymlinks, ...buildAgentsDirSymlinks(root)]);
   if (targets.includes("opencode")) {
     await writeOpencode(root, rules);
   }
 }
 // src/status.ts
-import fs10 from "fs/promises";
-async function checkGeneratedFile(root, rule) {
-  const filePath = copilotFilePath(root, rule.name);
-  try {
-    const [source, dest] = await Promise.all([
-      fs10.readFile(rule.path, "utf-8"),
-      fs10.readFile(filePath, "utf-8")
-    ]);
-    return { path: filePath, exists: true, upToDate: source === dest };
-  } catch {
-    return { path: filePath, exists: false, upToDate: false };
-  }
-}
-async function checkOpencodeStatus(root, _rules) {
+async function checkOpencodeStatus(root) {
   const existing = await readOpencode(root);
   if (!existing)
     return { exists: false, valid: false };
   return { exists: true, valid: existing["instructions"] === `${ONEAGENT_DIR}/instructions.md` };
 }
-async function checkCopilotPrompt(root, skill) {
-  const filePath = copilotPromptFilePath(root, skill.name);
-  const expected = buildCopilotPromptContent(skill);
-  try {
-    const content = await fs10.readFile(filePath, "utf-8");
-    return { path: filePath, exists: true, upToDate: content === expected };
-  } catch {
-    return { path: filePath, exists: false, upToDate: false };
-  }
-}
 async function checkStatus(root, config) {
-  const [rules, skills] = await Promise.all([readRules(root), readSkills(root)]);
+  const rules = await readRules(root);
   const targets = activeTargets(config);
   const allEntries = [
     ...buildMainSymlinks(root, targets),
     ...buildRulesSymlinks(root, targets),
     ...buildSkillSymlinks(root, targets),
     ...buildCommandSymlinks(root, targets),
+    ...targets.includes("copilot") ? buildCopilotRulesSymlinks(root, rules) : [],
     ...buildAgentsDirSymlinks(root)
   ];
   const symlinks = await Promise.all(allEntries.map(checkSymlink));
-  const generatedFiles = targets.includes("copilot") ? await Promise.all([
-    ...rules.map((rule) => checkGeneratedFile(root, rule)),
-    ...skills.map((skill) => checkCopilotPrompt(root, skill))
-  ]) : [];
-  const opencode = await checkOpencodeStatus(root, rules);
-  return { symlinks, generatedFiles, opencode };
+  const opencode = await checkOpencodeStatus(root);
+  return { symlinks, opencode };
 }
 // src/apply-template.ts
 import path10 from "path";
-import fs11 from "fs/promises";
+import fs8 from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -669,11 +588,11 @@ async function resolveExtends(child, resolveBuiltin) {
 }
 async function applyTemplateFiles(root, template) {
   const oneagentDir = path10.join(root, ONEAGENT_DIR);
-  await fs11.mkdir(path10.join(oneagentDir, "rules"), { recursive: true });
-  await fs11.mkdir(path10.join(oneagentDir, "skills"), { recursive: true });
-  await fs11.writeFile(path10.join(oneagentDir, "instructions.md"), template.instructions);
+  await fs8.mkdir(path10.join(oneagentDir, "rules"), { recursive: true });
+  await fs8.mkdir(path10.join(oneagentDir, "skills"), { recursive: true });
+  await fs8.writeFile(path10.join(oneagentDir, "instructions.md"), template.instructions);
   for (const rule of template.rules) {
-    await fs11.writeFile(path10.join(oneagentDir, "rules", `${rule.name}.md`), rule.content);
+    await fs8.writeFile(path10.join(oneagentDir, "rules", `${rule.name}.md`), rule.content);
   }
 }
 async function installTemplateSkills(root, template) {
@@ -819,10 +738,6 @@ export {
   installTemplatePlugins,
   installBuiltinSkill,
   getAgentDef,
-  generateCopilotSkills,
-  generateCopilotSkill,
-  generateCopilotRules,
-  generateCopilotRule,
   generate,
   filesHaveSameContent,
   fetchTemplateFromGitHub,
@@ -831,20 +746,17 @@ export {
   detectExistingFiles,
   createSymlink,
   createAllSymlinks,
-  copilotPromptFilePath,
   copilotFilePath,
   configExists,
   cleanupAgentDir,
   checkSymlink,
   checkStatus,
   checkOpencodeStatus,
-  checkGeneratedFile,
-  checkCopilotPrompt,
   buildSkillSymlinks,
   buildRulesSymlinks,
   buildOpencodeConfig,
   buildMainSymlinks,
-  buildCopilotPromptContent,
+  buildCopilotRulesSymlinks,
   buildCommandSymlinks,
   buildAgentsDirSymlinks,
   applyTemplateFiles,

package/dist/status.d.ts

@@ -1,5 +1,3 @@
-import type { Config, GeneratedFileCheck, OpenCodeCheck, RuleFile, StatusResult } from "./types.ts";
-export declare function checkGeneratedFile(root: string, rule: RuleFile): Promise<GeneratedFileCheck>;
-export declare function checkOpencodeStatus(root: string, _rules: RuleFile[]): Promise<OpenCodeCheck>;
-export declare function checkCopilotPrompt(root: string, skill: import("./types.ts").SkillFile): Promise<GeneratedFileCheck>;
+import type { Config, OpenCodeCheck, StatusResult } from "./types.ts";
+export declare function checkOpencodeStatus(root: string): Promise<OpenCodeCheck>;
 export declare function checkStatus(root: string, config: Config): Promise<StatusResult>;

package/dist/types.d.ts

@@ -36,14 +36,8 @@ export interface SymlinkCheck extends SymlinkEntry {
 }
 export interface StatusResult {
     symlinks: SymlinkCheck[];
-    generatedFiles: GeneratedFileCheck[];
     opencode: OpenCodeCheck;
 }
-export interface GeneratedFileCheck {
-    path: string;
-    exists: boolean;
-    upToDate: boolean;
-}
 export interface OpenCodeCheck {
     exists: boolean;
     valid: boolean;

package/package.json

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