@moskala/oneagent-core 0.4.0 → 0.4.2

package/dist/opencode.d.ts

@@ -0,0 +1,5 @@
+import type { RuleFile } from "./types.ts";
+export declare function readOpencode(root: string): Promise<Record<string, unknown> | null>;
+export declare function buildOpencodeConfig(existing: Record<string, unknown> | null): object;
+export declare function addOpenCodePlugin(root: string, id: string): Promise<void>;
+export declare function writeOpencode(root: string, _rules: RuleFile[]): Promise<void>;

package/dist/rules.d.ts

@@ -0,0 +1,2 @@
+import type { RuleFile } from "./types.ts";
+export declare function readRules(root: string): Promise<RuleFile[]>;

package/dist/skills.d.ts

@@ -0,0 +1,11 @@
+import type { SkillFile } from "./types.ts";
+declare const VALID_MODES: readonly ["ask", "edit", "agent"];
+type SkillMode = (typeof VALID_MODES)[number];
+export declare function parseSkillFrontmatter(raw: string): {
+    description: string;
+    mode: SkillMode;
+    content: string;
+};
+export declare function readSkillFile(filePath: string): Promise<SkillFile>;
+export declare function readSkills(root: string): Promise<SkillFile[]>;
+export {};

package/dist/status.d.ts

@@ -0,0 +1,5 @@
+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>;
+export declare function checkStatus(root: string, config: Config): Promise<StatusResult>;

package/dist/symlinks.d.ts

@@ -0,0 +1,12 @@
+import type { AgentTarget, SymlinkCheck, SymlinkEntry } from "./types.ts";
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function createSymlink(symlinkPath: string, target: string): Promise<void>;
+export declare function buildMainSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[];
+export declare function buildRulesSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[];
+export declare function buildSkillSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[];
+export declare function buildCommandSymlinks(root: string, targets: AgentTarget[]): SymlinkEntry[];
+export declare function buildAgentsDirSymlinks(root: string): SymlinkEntry[];
+export declare function migrateRuleAndSkillFiles(root: string): Promise<void>;
+export declare function cleanupAgentDir(root: string, target: import("./types.ts").AgentTarget): Promise<void>;
+export declare function createAllSymlinks(entries: SymlinkEntry[]): Promise<void>;
+export declare function checkSymlink(entry: SymlinkEntry): Promise<SymlinkCheck>;

package/dist/types.d.ts

@@ -0,0 +1,50 @@
+export type AgentTarget = "claude" | "cursor" | "windsurf" | "opencode" | "copilot";
+export interface Config {
+    version: 1;
+    targets: Record<AgentTarget, boolean>;
+}
+export interface DetectedFile {
+    relativePath: string;
+    absolutePath: string;
+    sizeBytes: number;
+    modifiedAt: Date;
+    content: string;
+}
+export interface RuleFile {
+    name: string;
+    path: string;
+}
+export interface CommandFile {
+    name: string;
+    path: string;
+}
+export interface SkillFile {
+    name: string;
+    path: string;
+    description: string;
+    mode: "ask" | "edit" | "agent";
+    content: string;
+}
+export interface SymlinkEntry {
+    symlinkPath: string;
+    target: string;
+    label: string;
+}
+export interface SymlinkCheck extends SymlinkEntry {
+    exists: boolean;
+    valid: boolean;
+}
+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.0",
+  "version": "0.4.2",
   "type": "module",
   "description": "Core library for oneagent — one source of truth for AI agent rules",
   "license": "MIT",
@@ -8,16 +8,20 @@
     "type": "git",
     "url": "https://github.com/moskalakamil/oneagent"
   },
-  "module": "./src/index.ts",
-  "main": "./src/index.ts",
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
-    "src",
-    "!src/__tests__"
+    "dist"
   ],
   "scripts": {
+    "build": "bun ./scripts/build.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test"
   },

package/src/agents.ts

@@ -1,76 +0,0 @@
-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;
-  /** Whole-dir symlink for commands (relative to root). Omit if agent does not support custom commands. */
-  commandsDir?: 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",
-    commandsDir: ".claude/commands",
-  },
-  {
-    target: "cursor",
-    displayName: "Cursor",
-    hint: "AGENTS.md + .cursor/rules/",
-    detectIndicators: [".cursor", ".cursorrules"],
-    mainFile: "AGENTS.md",
-    rulesDir: ".cursor/rules",
-    skillsDir: ".cursor/skills",
-    deprecatedFiles: [".cursorrules"],
-    commandsDir: ".cursor/commands",
-  },
-  {
-    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",
-    commandsDir: ".opencode/commands",
-  },
-  {
-    target: "copilot",
-    displayName: "GitHub Copilot",
-    hint: ".github/instructions/*.instructions.md",
-    detectIndicators: [".github/copilot-instructions.md", ".github/instructions"],
-    mainFile: ".github/copilot-instructions.md",
-    skillsDir: ".github/skills",
-    // rules: generated as <name>.instructions.md files, not symlinks
-  },
-];
-
-export function getAgentDef(target: AgentTarget): AgentDefinition {
-  return AGENT_DEFINITIONS.find((d) => d.target === target)!;
-}

package/src/apply-template.ts

@@ -1,335 +0,0 @@
-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";
-import { ONEAGENT_DIR } from "./constants.ts";
-
-const execFileAsync = promisify(execFile);
-
-export interface TemplatePlugin {
-  target: AgentTarget;
-  id: string;
-}
-
-export interface SkillEntry {
-  repo: string;
-  skill: string;
-}
-
-export interface TemplateDefinition {
-  name: string;
-  description: string;
-  skills: SkillEntry[];
-  plugins: TemplatePlugin[];
-  instructions: string;
-  rules: Array<{ name: string; content: string }>;
-}
-
-// Parses name, description, skills and plugins from a template.yml string.
-// This is the single source of truth for the template.yml format — used by
-// both builtin template loading and GitHub URL template fetching.
-export function parseTemplateYaml(yamlText: string, fallbackName = "custom"): Pick<TemplateDefinition, "name" | "description" | "skills" | "plugins"> & { extends?: string } {
-  const nameMatch = yamlText.match(/^name:\s*(.+)$/m);
-  const name = nameMatch?.[1]?.trim() ?? fallbackName;
-
-  const descMatch = yamlText.match(/^description:\s*(.+)$/m);
-  const description = descMatch?.[1]?.trim() ?? "";
-
-  const extendsMatch = yamlText.match(/^extends:\s*(.+)$/m);
-  const extendsValue = extendsMatch?.[1]?.trim();
-
-  const skills = parseSkillsFromYaml(yamlText);
-  const plugins = parsePluginsFromYaml(yamlText);
-  return { name, description, skills, plugins, ...(extendsValue ? { extends: extendsValue } : {}) };
-}
-
-// Parses the `skills:` block from a template.yml string.
-// Expects entries in the format:
-//   skills:
-//     - repo: https://github.com/owner/skills
-//       skill: skill-name
-export function parseSkillsFromYaml(yamlText: string): SkillEntry[] {
-  const skills: SkillEntry[] = [];
-  const section = yamlText.match(/^skills:\s*\n((?:(?:  -.+|\s{4}.+)\n?)*)/m);
-  if (!section) return skills;
-  const block = section[1]!;
-  const entries = block.split(/\n(?=  -)/);
-  for (const entry of entries) {
-    const repoMatch = entry.match(/repo:\s*(\S+)/);
-    const skillMatch = entry.match(/skill:\s*(\S+)/);
-    if (repoMatch && skillMatch) {
-      skills.push({ repo: repoMatch[1]!.trim(), skill: skillMatch[1]!.trim() });
-    }
-  }
-  return skills;
-}
-
-// 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;
-}
-
-// Resolves the `extends` field — loads parent template from builtin name or GitHub URL.
-// Merges skills, plugins, rules (parent first, then child).
-// Instructions are NOT inherited — each template has its own.
-export async function resolveExtends(
-  child: TemplateDefinition & { extends?: string },
-  resolveBuiltin?: (name: string) => Promise<TemplateDefinition | null>,
-): Promise<TemplateDefinition> {
-  if (!child.extends) return child;
-
-  let parent: TemplateDefinition;
-  if (child.extends.startsWith("https://")) {
-    parent = await fetchTemplateFromGitHub(child.extends);
-  } else if (resolveBuiltin) {
-    const resolved = await resolveBuiltin(child.extends);
-    if (!resolved) throw new Error(`Unknown builtin template: "${child.extends}"`);
-    parent = resolved;
-  } else {
-    throw new Error(`Cannot resolve extends: "${child.extends}"`);
-  }
-
-  return {
-    name: child.name,
-    description: child.description,
-    instructions: child.instructions,
-    skills: [...parent.skills, ...child.skills],
-    plugins: [...parent.plugins, ...child.plugins],
-    rules: [...parent.rules, ...child.rules],
-  };
-}
-
-// 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> {
-  const oneagentDir = path.join(root, ONEAGENT_DIR);
-
-  await fs.mkdir(path.join(oneagentDir, "rules"), { recursive: true });
-  await fs.mkdir(path.join(oneagentDir, "skills"), { recursive: true });
-
-  await fs.writeFile(path.join(oneagentDir, "instructions.md"), template.instructions);
-
-  for (const rule of template.rules) {
-    await fs.writeFile(path.join(oneagentDir, "rules", `${rule.name}.md`), rule.content);
-  }
-}
-
-export interface SkillInstallResult {
-  installed: SkillEntry[];
-  failed: Array<{ entry: SkillEntry; reason: string }>;
-}
-
-// Phase 2: installs skills via `npx skills add <repo> --skill <name>`.
-// Skills are installed sequentially to avoid race conditions — each `npx skills add` call
-// sets up agent directories and running them in parallel causes "skills 2" naming conflicts.
-// Call this AFTER generate() so agent directories exist.
-// Never throws — failed skills are collected and returned in the result.
-export async function installTemplateSkills(
-  root: string,
-  template: TemplateDefinition,
-): Promise<SkillInstallResult> {
-  const installed: SkillEntry[] = [];
-  const failed: Array<{ entry: SkillEntry; reason: string }> = [];
-
-  for (const entry of template.skills) {
-    try {
-      await execFileAsync("npx", ["skills", "add", entry.repo, "--skill", entry.skill, "--agent", "universal", "--yes"], { cwd: root });
-      installed.push(entry);
-    } catch (err) {
-      const reason = err instanceof Error ? err.message : String(err);
-      failed.push({ entry, reason });
-    }
-  }
-
-  return { installed, failed };
-}
-
-const BUILTIN_SKILL_REPO = "https://github.com/moskalakamil/oneagent";
-const BUILTIN_SKILL_NAME = "oneagent";
-
-// Installs the built-in oneagent skill that teaches agents how to work with the .oneagent/ directory.
-// Never throws — returns true if installed, false if failed.
-export async function installBuiltinSkill(root: string): Promise<boolean> {
-  try {
-    await execFileAsync("npx", ["skills", "add", BUILTIN_SKILL_REPO, "--skill", BUILTIN_SKILL_NAME, "--agent", "universal", "--yes"], { cwd: root });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export interface PluginInstallResult {
-  installed: TemplatePlugin[];
-  manual: TemplatePlugin[];
-  failed: Array<{ plugin: TemplatePlugin; reason: string }>;
-}
-
-// 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)
-// Never throws — failed plugins are collected and returned in the result.
-export async function installTemplatePlugins(
-  root: string,
-  template: TemplateDefinition,
-  activeTargets: AgentTarget[],
-): Promise<PluginInstallResult> {
-  const installed: TemplatePlugin[] = [];
-  const manual: TemplatePlugin[] = [];
-  const failed: Array<{ plugin: TemplatePlugin; reason: string }> = [];
-
-  for (const plugin of template.plugins) {
-    if (!activeTargets.includes(plugin.target)) continue;
-
-    try {
-      switch (plugin.target) {
-        case "claude":
-          await execFileAsync("claude", ["plugin", "install", plugin.id], { cwd: root });
-          installed.push(plugin);
-          break;
-
-        case "copilot":
-          await execFileAsync("copilot", ["plugin", "install", plugin.id], { cwd: root });
-          installed.push(plugin);
-          break;
-
-        case "opencode":
-          await addOpenCodePlugin(root, plugin.id);
-          installed.push(plugin);
-          break;
-
-        case "cursor":
-          manual.push(plugin);
-          break;
-
-        case "windsurf":
-          // No marketplace yet — skip silently
-          break;
-      }
-    } catch (err) {
-      const reason = err instanceof Error ? err.message : String(err);
-      failed.push({ plugin, reason });
-    }
-  }
-
-  return { installed, manual, failed };
-}
-
-// Fetches a template from a GitHub URL.
-// Expects the repository to contain: template.yml, instructions.md, and optionally rules/*.md
-// When no branch is specified in the URL, queries the GitHub API for the default branch.
-export async function fetchTemplateFromGitHub(url: string): Promise<TemplateDefinition> {
-  const { owner, repo, branch, subdir } = parseGitHubUrl(url);
-  const branchExplicit = url.includes("/tree/");
-
-  const resolvedBranch = branchExplicit ? branch : await fetchDefaultBranch(owner, repo);
-  const rawBase = `https://raw.githubusercontent.com/${owner}/${repo}/${resolvedBranch}${subdir ? `/${subdir}` : ""}`;
-
-  const [yamlText, instructions] = await Promise.all([
-    fetchText(`${rawBase}/template.yml`),
-    fetchText(`${rawBase}/instructions.md`),
-  ]);
-
-  const parsed = parseTemplateYaml(yamlText);
-
-  // Try to list rules via GitHub API
-  const rules = await fetchGitHubRules(url);
-
-  const base = { ...parsed, instructions, rules };
-  return resolveExtends(base);
-}
-
-async function fetchDefaultBranch(owner: string, repo: string): Promise<string> {
-  try {
-    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
-      headers: { Accept: "application/vnd.github.v3+json" },
-    });
-    if (!response.ok) return "main";
-    const data = (await response.json()) as { default_branch?: string };
-    return data.default_branch ?? "main";
-  } catch {
-    return "main";
-  }
-}
-
-async function fetchText(url: string): Promise<string> {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
-  }
-  return response.text();
-}
-
-interface GitHubUrlParts {
-  owner: string;
-  repo: string;
-  branch: string;
-  subdir: string; // "" for root, "path/to/dir" for subdirectories
-}
-
-function parseGitHubUrl(url: string): GitHubUrlParts {
-  // Supports:
-  //   https://github.com/owner/repo
-  //   https://github.com/owner/repo/tree/branch
-  //   https://github.com/owner/repo/tree/branch/path/to/subdir
-  const match = url.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+?)(?:\/(.+))?)?(?:\/)?$/);
-  if (!match) {
-    throw new Error(`Invalid GitHub URL: "${url}". Expected format: https://github.com/owner/repo`);
-  }
-  const [, owner, repo, branch = "main", subdir = ""] = match;
-  return { owner: owner!, repo: repo!, branch, subdir };
-}
-
-function githubUrlToRawBase(url: string): string {
-  const { owner, repo, branch, subdir } = parseGitHubUrl(url);
-  const base = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
-  return subdir ? `${base}/${subdir}` : base;
-}
-
-async function fetchGitHubRules(repoUrl: string): Promise<Array<{ name: string; content: string }>> {
-  const { owner, repo, branch, subdir } = parseGitHubUrl(repoUrl);
-  const rulesPath = subdir ? `${subdir}/rules` : "rules";
-  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${rulesPath}?ref=${branch}`;
-  try {
-    const response = await fetch(apiUrl, {
-      headers: { Accept: "application/vnd.github.v3+json" },
-    });
-    if (!response.ok) return [];
-
-    const files = (await response.json()) as Array<{ name: string; download_url: string | null }>;
-    const mdFiles = files.filter((f) => f.name.endsWith(".md") && f.download_url);
-
-    const rules = await Promise.all(
-      mdFiles.map(async (f) => {
-        const content = await fetchText(f.download_url!);
-        return { name: path.basename(f.name, ".md"), content };
-      }),
-    );
-    return rules;
-  } catch {
-    return [];
-  }
-}

package/src/commands.ts

@@ -1,17 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import type { CommandFile } from "./types.ts";
-import { ONEAGENT_DIR } from "./constants.ts";
-
-export async function readCommands(root: string): Promise<CommandFile[]> {
-  const commandsDir = path.join(root, ONEAGENT_DIR, "commands");
-  try {
-    const files = await fs.readdir(commandsDir);
-    return files
-      .filter((f) => f.endsWith(".md"))
-      .map((f) => ({ name: path.basename(f, ".md"), path: path.join(commandsDir, f) }))
-      .sort((a, b) => a.name.localeCompare(b.name));
-  } catch {
-    return [];
-  }
-}

package/src/config.ts

@@ -1,32 +0,0 @@
-import { parse, stringify } from "yaml";
-import path from "path";
-import fs from "fs/promises";
-import type { AgentTarget, Config } from "./types.ts";
-import { ONEAGENT_DIR } from "./constants.ts";
-
-const CONFIG_REL = `${ONEAGENT_DIR}/config.yml`;
-
-export const ALL_AGENT_TARGETS: AgentTarget[] = ["claude", "cursor", "windsurf", "opencode", "copilot"];
-
-export function activeTargets(config: Config): AgentTarget[] {
-  return ALL_AGENT_TARGETS.filter((t) => config.targets[t]);
-}
-
-export function makeTargets(...enabled: AgentTarget[]): Record<AgentTarget, boolean> {
-  return Object.fromEntries(ALL_AGENT_TARGETS.map((t) => [t, enabled.includes(t)])) as Record<AgentTarget, boolean>;
-}
-
-export async function configExists(root: string): Promise<boolean> {
-  return fs.access(path.join(root, CONFIG_REL)).then(() => true, () => false);
-}
-
-export async function readConfig(root: string): Promise<Config> {
-  const content = await fs.readFile(path.join(root, CONFIG_REL), "utf-8");
-  return parse(content) as Config;
-}
-
-export async function writeConfig(root: string, config: Config): Promise<void> {
-  const filePath = path.join(root, CONFIG_REL);
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, stringify(config));
-}

package/src/constants.ts

@@ -1 +0,0 @@
-export const ONEAGENT_DIR = ".oneagent";

package/src/copilot.ts

@@ -1,38 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import type { RuleFile, SkillFile } from "./types.ts";
-
-export function copilotFilePath(root: string, ruleName: string): string {
-  return path.join(root, ".github/instructions", `${ruleName}.instructions.md`);
-}
-
-export async function generateCopilotRule(root: string, rule: RuleFile): Promise<void> {
-  const destPath = copilotFilePath(root, rule.name);
-  await fs.mkdir(path.dirname(destPath), { recursive: true });
-  await fs.copyFile(rule.path, destPath);
-}
-
-export async function generateCopilotRules(root: string, rules: RuleFile[]): Promise<void> {
-  await Promise.all(rules.map((rule) => generateCopilotRule(root, rule)));
-}
-
-export function buildCopilotPromptContent(skill: SkillFile): string {
-  const lines = ["---", `mode: "${skill.mode}"`];
-  if (skill.description) lines.push(`description: "${skill.description}"`);
-  lines.push("---", skill.content);
-  return lines.join("\n");
-}
-
-export function copilotPromptFilePath(root: string, skillName: string): string {
-  return path.join(root, ".github/prompts", `${skillName}.prompt.md`);
-}
-
-export async function generateCopilotSkill(root: string, skill: SkillFile): Promise<void> {
-  const filePath = copilotPromptFilePath(root, skill.name);
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, buildCopilotPromptContent(skill));
-}
-
-export async function generateCopilotSkills(root: string, skills: SkillFile[]): Promise<void> {
-  await Promise.all(skills.map((skill) => generateCopilotSkill(root, skill)));
-}