@balazsbarta/mp-skills 0.1.0

package/scripts/skills.mjs

@@ -0,0 +1,849 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+
+const TARGETS = ["codex", "claude-code", "opencode", "gemini-cli", "cursor", "generic"];
+const ALL_TARGETS = ["codex", "claude-code", "opencode", "gemini-cli", "cursor"];
+const TARGET_ALIASES = new Map([
+  ["codex", "codex"],
+  ["claude", "claude-code"],
+  ["claude-code", "claude-code"],
+  ["opencode", "opencode"],
+  ["gemini", "gemini-cli"],
+  ["gemini-cli", "gemini-cli"],
+  ["cursor", "cursor"],
+  ["cursor-cli", "cursor"],
+  ["generic", "generic"],
+  ["other", "generic"],
+  ["others", "generic"],
+]);
+const SOURCE_ALIASES = new Map([
+  ["mp-skills", "balazsbarta/mp-skills"],
+]);
+
+const HELP_TEXT = `
+skills - Install skill packs for coding assistants
+
+Usage:
+  skills add [source] [options]
+  skills select [source] [options]  # alias for interactive add
+  skills targets
+  skills --help
+
+Examples:
+  skills add mp-skills
+  skills add mp-skills --mode copy
+  skills add . --target codex --mode symlink
+  skills add . --target cursor --cursor-project /path/to/project
+  skills add . --target generic --dest /path/to/agent/skills
+  skills select mp-skills
+
+Arguments:
+  source                  Optional local path or GitHub repo slug (owner/repo)
+                          "mp-skills" maps to "balazsbarta/mp-skills"
+
+Options:
+  --target <name>         (add non-interactive mode) codex | claude-code | opencode | gemini-cli | cursor | generic | all
+  --mode <mode>           (add/select) copy | symlink
+  --cursor-project <dir>  (add/select) Project root for Cursor rules
+  --dest <dir>            (add/select) Destination folder used by target=generic
+  -h, --help              Show help
+
+Interactive install:
+  "skills add" starts guided prompts by default (targets, skills, mode).
+  "skills select" behaves the same (compatibility alias).
+  Unselected already-installed skills are kept.
+
+Non-interactive install:
+  Provide --target to run "skills add" without prompts.
+`;
+
+const TARGET_PROMPT_OPTIONS = [
+  { value: "codex", label: "codex" },
+  { value: "claude-code", label: "claude-code" },
+  { value: "opencode", label: "opencode" },
+  { value: "gemini-cli", label: "gemini-cli" },
+  { value: "cursor", label: "cursor" },
+  { value: "generic", label: "generic" },
+  { value: "all", label: "all (codex, claude-code, opencode, gemini-cli, cursor)" },
+];
+
+const MODE_PROMPT_OPTIONS = [
+  { value: "copy", label: "copy" },
+  { value: "symlink", label: "symlink" },
+];
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    print(HELP_TEXT.trim());
+    return;
+  }
+
+  const command = argv[0];
+  const args = argv.slice(1);
+
+  if (command === "targets") {
+    print("Supported targets:");
+    for (const target of TARGETS) {
+      print(`- ${target}`);
+    }
+    print("- all");
+    return;
+  }
+
+  if (command === "add") {
+    await runAddCommand(args);
+    return;
+  }
+
+  if (command === "select") {
+    await runSelectCommand(args);
+    return;
+  }
+
+  fatal(`Unknown command: ${command}\n\n${HELP_TEXT.trim()}`);
+}
+
+async function runAddCommand(args) {
+  const options = parseAddArgs(args);
+  if (!options.hasExplicitTarget) {
+    await runInteractiveInstall(options);
+    return;
+  }
+
+  const cleanupPaths = [];
+
+  try {
+    const context = await loadInstallContext(options.sourceArg, cleanupPaths);
+    const targets = resolveTargets(options.targetArg);
+    const effectiveMode = normalizeModeForSource(options.mode || "copy", context.source);
+    const summary = await installToTargets({
+      targets,
+      skills: context.skills,
+      mode: effectiveMode,
+      cursorProject: options.cursorProject || process.cwd(),
+      dest: options.dest,
+    });
+    printInstallSummary(summary);
+  } finally {
+    await cleanupTemporaryPaths(cleanupPaths);
+  }
+}
+
+async function runSelectCommand(args) {
+  const options = parseSelectArgs(args);
+  await runInteractiveInstall(options);
+}
+
+async function runInteractiveInstall(options) {
+  ensureInteractiveTerminal();
+
+  const cleanupPaths = [];
+  try {
+    const context = await loadInstallContext(options.sourceArg, cleanupPaths);
+    const selection = await promptInstallSelection(context.skills, options);
+    const selectedSkills = selectSkillsByName(context.skills, selection.skillNames);
+    const effectiveMode = normalizeModeForSource(selection.mode, context.source);
+
+    const summary = await installToTargets({
+      targets: selection.targets,
+      skills: selectedSkills,
+      mode: effectiveMode,
+      cursorProject: selection.cursorProject,
+      dest: selection.dest,
+    });
+    printInstallSummary(summary);
+  } finally {
+    await cleanupTemporaryPaths(cleanupPaths);
+  }
+}
+
+async function loadInstallContext(sourceArg, cleanupPaths) {
+  const source = await resolveSource(sourceArg, cleanupPaths);
+  const skillsRoot = await findSkillsRoot(source.root);
+  const skills = await readSkills(skillsRoot);
+  if (skills.length === 0) {
+    fatal(`No skills found in: ${skillsRoot}`);
+  }
+  return { source, skillsRoot, skills };
+}
+
+function normalizeModeForSource(mode, source) {
+  if (source.isTemporary && mode === "symlink") {
+    print("Source is temporary (GitHub clone), falling back to copy mode.");
+    return "copy";
+  }
+  return mode;
+}
+
+async function installToTargets({ targets, skills, mode, cursorProject, dest }) {
+  const summary = [];
+
+  for (const target of targets) {
+    if (target === "codex") {
+      const installed = await installCodex(skills, mode);
+      summary.push(`codex: ${installed} skills`);
+      continue;
+    }
+    if (target === "claude-code") {
+      const installed = await installClaudeCode(skills, mode);
+      summary.push(`claude-code: ${installed} skills`);
+      continue;
+    }
+    if (target === "opencode") {
+      const installed = await installOpenCode(skills, mode);
+      summary.push(`opencode: ${installed} skills`);
+      continue;
+    }
+    if (target === "gemini-cli") {
+      const installed = await installGemini(skills, mode);
+      summary.push(`gemini-cli: ${installed} commands`);
+      continue;
+    }
+    if (target === "cursor") {
+      const effectiveCursorProject = cursorProject || process.cwd();
+      const installed = await installCursor(skills, mode, effectiveCursorProject);
+      summary.push(`cursor: ${installed} rules`);
+      continue;
+    }
+    if (target === "generic") {
+      const installed = await installGeneric(skills, mode, dest);
+      summary.push(`generic: ${installed} skills`);
+      continue;
+    }
+    fatal(`Unsupported target: ${target}`);
+  }
+
+  return summary;
+}
+
+function printInstallSummary(summary) {
+  print("\nInstall complete:");
+  for (const item of summary) {
+    print(`- ${item}`);
+  }
+}
+
+async function cleanupTemporaryPaths(cleanupPaths) {
+  for (const tempPath of cleanupPaths) {
+    await fs.rm(tempPath, { recursive: true, force: true });
+  }
+}
+
+function ensureInteractiveTerminal() {
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    return;
+  }
+  fatal(
+    'Interactive mode requires a TTY terminal. Use "skills add --target <name>" for non-interactive installs.',
+  );
+}
+
+async function promptInstallSelection(skills, options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+  });
+
+  try {
+    print("");
+    print("Interactive skill installer");
+    print("===========================");
+
+    const rawTargets = await promptMultiChoice({
+      rl,
+      title: "Select target agent(s):",
+      prompt: "Enter target number(s), separated by commas",
+      options: TARGET_PROMPT_OPTIONS,
+      required: true,
+    });
+
+    const targets = normalizeInteractiveTargets(rawTargets);
+    const skillOptions = [
+      ...skills.map((skill) => ({ value: skill.name, label: skill.name })),
+      { value: "__all__", label: "all (install every discovered skill)" },
+    ];
+
+    const rawSkillNames = await promptMultiChoice({
+      rl,
+      title: "Select skill(s) to install:",
+      prompt: "Enter skill number(s), separated by commas",
+      options: skillOptions,
+      required: true,
+    });
+
+    const skillNames =
+      rawSkillNames.includes("__all__") ? skills.map((skill) => skill.name) : rawSkillNames;
+    if (skillNames.length === 0) {
+      throw new Error("At least one skill must be selected.");
+    }
+
+    const mode =
+      options.mode ||
+      (await promptSingleChoice({
+        rl,
+        title: "Select install mode:",
+        prompt: "Enter mode number",
+        options: MODE_PROMPT_OPTIONS,
+      }));
+
+    let cursorProject = options.cursorProject;
+    let dest = options.dest;
+
+    if (targets.includes("cursor") && !cursorProject) {
+      cursorProject = await promptRequiredText({
+        rl,
+        label: "Cursor project path",
+        defaultValue: process.cwd(),
+      });
+    }
+
+    if (targets.includes("generic") && !dest) {
+      dest = await promptRequiredText({
+        rl,
+        label: "Destination path for generic target",
+        defaultValue: "",
+      });
+    }
+
+    print("");
+    print("Selection summary:");
+    print(`- targets: ${targets.join(", ")}`);
+    print(`- skills: ${skillNames.join(", ")}`);
+    print(`- mode: ${mode}`);
+    if (targets.includes("cursor")) {
+      print(`- cursor project: ${path.resolve(cursorProject || process.cwd())}`);
+    }
+    if (targets.includes("generic")) {
+      print(`- generic destination: ${path.resolve(dest || "")}`);
+    }
+
+    const confirmed = await promptYesNo({
+      rl,
+      question: "Continue with installation?",
+      defaultYes: true,
+    });
+    if (!confirmed) {
+      throw new Error("Installation canceled.");
+    }
+
+    return {
+      targets,
+      skillNames,
+      mode,
+      cursorProject: cursorProject || process.cwd(),
+      dest,
+    };
+  } finally {
+    rl.close();
+  }
+}
+
+function normalizeInteractiveTargets(rawTargets) {
+  if (rawTargets.includes("all")) {
+    return [...ALL_TARGETS];
+  }
+  return rawTargets;
+}
+
+function selectSkillsByName(skills, names) {
+  const uniqueNames = [...new Set(names)];
+  const selected = skills.filter((skill) => uniqueNames.includes(skill.name));
+  if (selected.length === 0) {
+    fatal("No valid skills selected.");
+  }
+
+  const selectedNames = new Set(selected.map((skill) => skill.name));
+  const missing = uniqueNames.filter((name) => !selectedNames.has(name));
+  if (missing.length > 0) {
+    fatal(`Unknown selected skill(s): ${missing.join(", ")}`);
+  }
+  return selected;
+}
+
+async function promptSingleChoice({ rl, title, prompt, options }) {
+  while (true) {
+    print("");
+    print(title);
+    printNumberedOptions(options);
+    const answer = (await rl.question(`${prompt}: `)).trim();
+
+    const indexes = parseIndexInput(answer, options.length, false);
+    if (indexes) {
+      return options[indexes[0] - 1].value;
+    }
+
+    const retry = await promptRetry({ rl, reason: "Invalid selection." });
+    if (!retry) {
+      throw new Error("Installation canceled.");
+    }
+  }
+}
+
+async function promptMultiChoice({ rl, title, prompt, options, required }) {
+  while (true) {
+    print("");
+    print(title);
+    printNumberedOptions(options);
+    const answer = (await rl.question(`${prompt}: `)).trim();
+
+    const indexes = parseIndexInput(answer, options.length, true);
+    if (indexes && (!required || indexes.length > 0)) {
+      const values = indexes.map((index) => options[index - 1].value);
+      return dedupe(values);
+    }
+
+    const retry = await promptRetry({ rl, reason: "Invalid selection." });
+    if (!retry) {
+      throw new Error("Installation canceled.");
+    }
+  }
+}
+
+function printNumberedOptions(options) {
+  for (let i = 0; i < options.length; i += 1) {
+    print(`  ${i + 1}) ${options[i].label}`);
+  }
+}
+
+function parseIndexInput(raw, max, allowMultiple) {
+  if (!raw) {
+    return null;
+  }
+
+  const tokens = raw.split(",").map((token) => token.trim()).filter(Boolean);
+  if (tokens.length === 0) {
+    return null;
+  }
+  if (!allowMultiple && tokens.length !== 1) {
+    return null;
+  }
+
+  const indexes = [];
+  for (const token of tokens) {
+    if (!/^\d+$/.test(token)) {
+      return null;
+    }
+
+    const index = Number(token);
+    if (!Number.isInteger(index) || index < 1 || index > max) {
+      return null;
+    }
+    indexes.push(index);
+  }
+
+  return dedupe(indexes);
+}
+
+function dedupe(values) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    result.push(value);
+  }
+  return result;
+}
+
+async function promptRequiredText({ rl, label, defaultValue }) {
+  while (true) {
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    const answer = (await rl.question(`${label}${suffix}: `)).trim();
+    const value = answer || defaultValue;
+    if (value && value.trim().length > 0) {
+      return value.trim();
+    }
+
+    const retry = await promptRetry({ rl, reason: "Value cannot be empty." });
+    if (!retry) {
+      throw new Error("Installation canceled.");
+    }
+  }
+}
+
+async function promptRetry({ rl, reason }) {
+  print(reason);
+  return promptYesNo({
+    rl,
+    question: "Try again?",
+    defaultYes: true,
+  });
+}
+
+async function promptYesNo({ rl, question, defaultYes }) {
+  while (true) {
+    const suffix = defaultYes ? " [Y/n]" : " [y/N]";
+    const answer = (await rl.question(`${question}${suffix}: `)).trim().toLowerCase();
+    if (!answer) {
+      return defaultYes;
+    }
+    if (answer === "y" || answer === "yes") {
+      return true;
+    }
+    if (answer === "n" || answer === "no") {
+      return false;
+    }
+    print('Please answer "y" or "n".');
+  }
+}
+
+function parseAddArgs(args) {
+  let sourceArg = null;
+  let targetArg = "";
+  let mode = "";
+  let cursorProject = "";
+  let dest = "";
+  let hasExplicitTarget = false;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith("-") && !sourceArg) {
+      sourceArg = token;
+      continue;
+    }
+    if (token === "--target") {
+      hasExplicitTarget = true;
+      targetArg = readValue(args, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === "--mode") {
+      mode = readValue(args, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === "--cursor-project") {
+      cursorProject = readValue(args, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === "--dest") {
+      dest = readValue(args, i, token);
+      i += 1;
+      continue;
+    }
+    fatal(`Unknown argument: ${token}`);
+  }
+
+  if (mode && !["copy", "symlink"].includes(mode)) {
+    fatal(`Invalid --mode value: ${mode}. Use copy or symlink.`);
+  }
+
+  return { sourceArg, targetArg, mode, cursorProject, dest, hasExplicitTarget };
+}
+
+function parseSelectArgs(args) {
+  let sourceArg = null;
+  let mode = "";
+  let cursorProject = "";
+  let dest = "";
+
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith("-") && !sourceArg) {
+      sourceArg = token;
+      continue;
+    }
+    if (token === "--mode") {
+      mode = readValue(args, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === "--cursor-project") {
+      cursorProject = readValue(args, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === "--dest") {
+      dest = readValue(args, i, token);
+      i += 1;
+      continue;
+    }
+    fatal(`Unknown argument: ${token}`);
+  }
+
+  if (mode && !["copy", "symlink"].includes(mode)) {
+    fatal(`Invalid --mode value: ${mode}. Use copy or symlink.`);
+  }
+
+  return { sourceArg, mode, cursorProject, dest };
+}
+
+function readValue(args, index, flag) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("-")) {
+    fatal(`Missing value for ${flag}`);
+  }
+  return value;
+}
+
+function resolveTargets(rawTarget) {
+  if (rawTarget === "all") {
+    return [...ALL_TARGETS];
+  }
+
+  const names = rawTarget.split(",").map((item) => item.trim()).filter(Boolean);
+  if (names.length === 0) {
+    fatal(`Invalid --target value: ${rawTarget}`);
+  }
+
+  const targets = [];
+  for (const name of names) {
+    const mapped = TARGET_ALIASES.get(name);
+    if (!mapped) {
+      fatal(`Unknown target: ${name}. Run "skills targets" for valid values.`);
+    }
+    if (!targets.includes(mapped)) {
+      targets.push(mapped);
+    }
+  }
+  return targets;
+}
+
+async function resolveSource(sourceArg, cleanupPaths) {
+  if (!sourceArg) {
+    return {
+      root: path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."),
+      isTemporary: false,
+    };
+  }
+
+  if (SOURCE_ALIASES.has(sourceArg)) {
+    const mappedSource = SOURCE_ALIASES.get(sourceArg);
+    print(`Using source alias "${sourceArg}" -> "${mappedSource}"`);
+    return cloneGithubSource(mappedSource, cleanupPaths);
+  }
+
+  const localPath = path.resolve(sourceArg);
+  if (await pathExists(localPath)) {
+    return { root: localPath, isTemporary: false };
+  }
+
+  if (isGithubSlug(sourceArg)) {
+    return cloneGithubSource(sourceArg, cleanupPaths);
+  }
+
+  fatal(`Source not found: ${sourceArg}`);
+}
+
+async function cloneGithubSource(slug, cleanupPaths) {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "skills-source-"));
+  cleanupPaths.push(tempRoot);
+
+  const cloneUrl = `https://github.com/${slug}.git`;
+  print(`Cloning ${cloneUrl} ...`);
+  execFileSync("git", ["clone", "--depth", "1", cloneUrl, tempRoot], {
+    stdio: "inherit",
+  });
+
+  return { root: tempRoot, isTemporary: true };
+}
+
+function isGithubSlug(value) {
+  return /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(value);
+}
+
+async function findSkillsRoot(rootPath) {
+  const candidates = [path.join(rootPath, ".agents", "skills"), path.join(rootPath, "skills")];
+
+  for (const candidate of candidates) {
+    if (!(await pathExists(candidate))) {
+      continue;
+    }
+
+    const entries = await fs.readdir(candidate, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const skillPath = path.join(candidate, entry.name, "SKILL.md");
+      if (await pathExists(skillPath)) {
+        return candidate;
+      }
+    }
+  }
+
+  fatal(
+    `Could not find skills under ${rootPath}. Expected ".agents/skills" or "skills" with SKILL.md files.`,
+  );
+}
+
+async function readSkills(skillsRoot) {
+  const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+  const skills = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const dir = path.join(skillsRoot, entry.name);
+    const skillFile = path.join(dir, "SKILL.md");
+    if (!(await pathExists(skillFile))) {
+      continue;
+    }
+
+    const content = await fs.readFile(skillFile, "utf8");
+    skills.push({
+      name: entry.name,
+      dir,
+      skillFile,
+      content,
+    });
+  }
+
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+async function installCodex(skills, mode) {
+  const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+  const targetRoot = path.join(codexHome, "skills");
+  return installSkillDirectories(skills, targetRoot, mode, "Codex");
+}
+
+async function installClaudeCode(skills, mode) {
+  const claudeHome = process.env.CLAUDE_HOME || path.join(os.homedir(), ".claude");
+  const targetRoot = path.join(claudeHome, "skills");
+  return installSkillDirectories(skills, targetRoot, mode, "Claude Code");
+}
+
+async function installOpenCode(skills, mode) {
+  const opencodeHome =
+    process.env.OPENCODE_HOME ||
+    process.env.OPENCODE_CONFIG_DIR ||
+    path.join(os.homedir(), ".config", "opencode");
+  const targetRoot = path.join(opencodeHome, "skills");
+  return installSkillDirectories(skills, targetRoot, mode, "OpenCode");
+}
+
+async function installGeneric(skills, mode, destRaw) {
+  if (!destRaw) {
+    fatal(`target=generic requires --dest /path/to/skills`);
+  }
+  const targetRoot = path.resolve(destRaw);
+  return installSkillDirectories(skills, targetRoot, mode, "Generic");
+}
+
+async function installSkillDirectories(skills, targetRoot, mode, label) {
+  await fs.mkdir(targetRoot, { recursive: true });
+  let installed = 0;
+
+  for (const skill of skills) {
+    const targetPath = path.join(targetRoot, skill.name);
+    await replacePath(targetPath);
+
+    if (mode === "symlink") {
+      await fs.symlink(skill.dir, targetPath, "dir");
+    } else {
+      await fs.cp(skill.dir, targetPath, { recursive: true });
+    }
+    installed += 1;
+  }
+
+  print(`Installed ${label} skills to ${targetRoot}`);
+  return installed;
+}
+
+async function installGemini(skills, mode) {
+  const geminiHome = process.env.GEMINI_HOME || path.join(os.homedir(), ".gemini");
+  const targetRoot = path.join(geminiHome, "commands", "mp-skills");
+  await fs.mkdir(targetRoot, { recursive: true });
+
+  if (mode === "symlink") {
+    print("Gemini CLI uses generated TOML wrappers; using direct install for Gemini.");
+  }
+
+  let installed = 0;
+  for (const skill of skills) {
+    const targetPath = path.join(targetRoot, `${skill.name}.toml`);
+    const toml = buildGeminiToml(skill);
+    await replacePath(targetPath);
+    await fs.writeFile(targetPath, toml, "utf8");
+    installed += 1;
+  }
+
+  print(`Installed Gemini CLI commands to ${targetRoot}`);
+  return installed;
+}
+
+function buildGeminiToml(skill) {
+  const prompt = escapeTomlMultiline(skill.content.trimEnd());
+  return `description = "mp-skills: ${skill.name}"\n\nprompt = """\n${prompt}\n"""\n`;
+}
+
+function escapeTomlMultiline(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+async function installCursor(skills, mode, cursorProjectRaw) {
+  const cursorProject = path.resolve(cursorProjectRaw);
+  const targetRoot = path.join(cursorProject, ".cursor", "rules", "mp-skills");
+  await fs.mkdir(targetRoot, { recursive: true });
+
+  if (mode === "symlink") {
+    print("Cursor uses generated .mdc rules; using direct install for Cursor.");
+  }
+
+  let installed = 0;
+  for (const skill of skills) {
+    const targetPath = path.join(targetRoot, `${skill.name}.mdc`);
+    const content = buildCursorRule(skill);
+    await replacePath(targetPath);
+    await fs.writeFile(targetPath, content, "utf8");
+    installed += 1;
+  }
+
+  print(`Installed Cursor rules to ${targetRoot}`);
+  return installed;
+}
+
+function buildCursorRule(skill) {
+  return `---
+description: "mp-skills: ${skill.name}"
+alwaysApply: false
+---
+# ${skill.name}
+
+Use this rule when you want to run the \`${skill.name}\` workflow from the shared mp-skills library.
+
+${skill.content.trimEnd()}
+`;
+}
+
+async function replacePath(targetPath) {
+  await fs.rm(targetPath, { recursive: true, force: true });
+  await fs.mkdir(path.dirname(targetPath), { recursive: true });
+}
+
+async function pathExists(candidatePath) {
+  try {
+    await fs.access(candidatePath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function print(message) {
+  process.stdout.write(`${message}\n`);
+}
+
+function fatal(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+main().catch((error) => {
+  fatal(error instanceof Error ? error.message : String(error));
+});