skill-rules 0.1.0

package/dist/index.js

@@ -0,0 +1,1125 @@
+#!/usr/bin/env node
+
+// src/cli.jsx
+import { Command } from "commander";
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath } from "url";
+import { join as join11, dirname } from "path";
+
+// src/commands/run.jsx
+import React2, { useEffect, useState as useState2 } from "react";
+import { render, Box as Box2, Text as Text2, useApp } from "ink";
+import { Spinner } from "@inkjs/ui";
+
+// src/lib/ides.js
+import { existsSync } from "fs";
+import { join } from "path";
+var IDES = {
+  claude: {
+    name: "Claude Code",
+    detectDir: ".claude",
+    skillsDir: ".claude/skills"
+  },
+  cursor: {
+    name: "Cursor",
+    detectDir: ".cursor",
+    skillsDir: ".cursor/skills"
+  },
+  windsurf: {
+    name: "Windsurf",
+    detectDir: ".windsurf",
+    skillsDir: ".windsurf/skills"
+  },
+  openhands: {
+    name: "OpenHands",
+    detectDir: ".openhands",
+    skillsDir: ".openhands/skills"
+  },
+  agents: {
+    // Shared by: GitHub Copilot, Cline, VS Code, OpenCode, Codex, Kiro, and others
+    name: "Agents (Copilot, Cline, VS Code, OpenCode, Codex, Kiro)",
+    detectDir: ".agents",
+    skillsDir: ".agents/skills"
+  }
+};
+function detectIDEs(cwd = process.cwd()) {
+  return Object.entries(IDES).filter(([, ide]) => existsSync(join(cwd, ide.detectDir))).map(([id, ide]) => ({ id, ...ide }));
+}
+
+// src/lib/lock.js
+import { readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var LOCK_FILE = "skills-lock.json";
+function readLock(cwd = process.cwd()) {
+  const lockPath = join2(cwd, LOCK_FILE);
+  if (!existsSync2(lockPath)) {
+    return { version: 1, skills: {} };
+  }
+  try {
+    return JSON.parse(readFileSync(lockPath, "utf8"));
+  } catch {
+    throw new Error(`Failed to parse ${LOCK_FILE}. Delete it and run: skill-rules init`);
+  }
+}
+function writeLock(lock, cwd = process.cwd()) {
+  const lockPath = join2(cwd, LOCK_FILE);
+  writeFileSync(lockPath, JSON.stringify(lock, null, 2) + "\n");
+}
+function setSkillTracked(lock, skillName, tracked) {
+  if (!lock.skills[skillName]) return lock;
+  if (tracked) {
+    lock.skills[skillName].track = true;
+  } else {
+    delete lock.skills[skillName].track;
+  }
+  return lock;
+}
+
+// src/lib/rules.js
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var RULES_FILE = "skills.rules";
+function readRules(cwd = process.cwd()) {
+  const rulesPath = join3(cwd, RULES_FILE);
+  if (!existsSync3(rulesPath)) return null;
+  try {
+    return JSON.parse(readFileSync2(rulesPath, "utf8"));
+  } catch {
+    throw new Error(`Failed to parse ${RULES_FILE}. Delete it and run: skill-rules init`);
+  }
+}
+function writeRules(rules, cwd = process.cwd()) {
+  const rulesPath = join3(cwd, RULES_FILE);
+  writeFileSync2(rulesPath, JSON.stringify(rules, null, 2) + "\n");
+}
+function createEmptyRules() {
+  return { version: 1, stages: {} };
+}
+function getActiveSkills(rules, stage) {
+  if (!rules) return [];
+  const { stages } = rules;
+  if (stage) {
+    return stages[stage] ?? [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const skills of Object.values(stages)) {
+    for (const s of skills) seen.add(s);
+  }
+  return [...seen];
+}
+function addSkillToStage(rules, skillName, stage) {
+  if (!rules.stages[stage]) rules.stages[stage] = [];
+  if (!rules.stages[stage].includes(skillName)) {
+    rules.stages[stage].push(skillName);
+  }
+  return rules;
+}
+function removeSkillFromStage(rules, skillName, stage) {
+  if (stage) {
+    rules.stages[stage] = (rules.stages[stage] ?? []).filter((s) => s !== skillName);
+    if (rules.stages[stage].length === 0) delete rules.stages[stage];
+  } else {
+    for (const key of Object.keys(rules.stages)) {
+      rules.stages[key] = rules.stages[key].filter((s) => s !== skillName);
+      if (rules.stages[key].length === 0) delete rules.stages[key];
+    }
+  }
+  return rules;
+}
+function listStages(rules) {
+  return Object.keys(rules?.stages ?? {});
+}
+
+// src/lib/ignorer.js
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+var MARKER_START = "# skill-rules [start]";
+var MARKER_END = "# skill-rules [end]";
+function updateGitignore(cwd, patterns) {
+  const gitignorePath = join4(cwd, ".gitignore");
+  let content = existsSync4(gitignorePath) ? readFileSync3(gitignorePath, "utf8") : "";
+  const escapedStart = escapeRegex(MARKER_START);
+  const escapedEnd = escapeRegex(MARKER_END);
+  content = content.replace(new RegExp(`\\n?${escapedStart}[\\s\\S]*?${escapedEnd}\\n?`, "g"), "");
+  if (patterns.length === 0) {
+    writeFileSync3(gitignorePath, content);
+    return;
+  }
+  const normalized = patterns.map((p) => p.replace(/\\/g, "/"));
+  const section = `
+${MARKER_START}
+${normalized.join("\n")}
+${MARKER_END}
+`;
+  writeFileSync3(gitignorePath, content.trimEnd() + section);
+}
+function buildIgnorePatterns(ides, trackedSkillNames = []) {
+  const patterns = [".skill-rules/"];
+  for (const ide of ides) {
+    patterns.push(ide.skillsDir);
+    for (const skill of trackedSkillNames) {
+      patterns.push(`!${ide.skillsDir}/${skill}`);
+    }
+  }
+  return patterns;
+}
+function syncGitignore(cwd, ides, lock) {
+  const tracked = Object.entries(lock?.skills ?? {}).filter(([, info]) => info.track).map(([name]) => name);
+  updateGitignore(cwd, buildIgnorePatterns(ides, tracked));
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/lib/syncer.js
+import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
+
+// src/lib/copy.js
+import { readdirSync, statSync, copyFileSync, mkdirSync } from "fs";
+import { join as join5 } from "path";
+function copyDirSync(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  for (const entry of readdirSync(src)) {
+    const srcPath = join5(src, entry);
+    const destPath = join5(dest, entry);
+    if (statSync(srcPath).isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/lib/syncer.js
+function findSkillSources(cwd, ides, skillName) {
+  return ides.filter((ide) => {
+    const p = join6(cwd, ide.skillsDir, skillName);
+    return existsSync5(p) && statSync2(p).isDirectory();
+  });
+}
+function syncSkillToMissingIDEs(cwd, ides, skillName, sourceIde) {
+  const sourcePath = join6(cwd, sourceIde.skillsDir, skillName);
+  let copied = 0;
+  for (const ide of ides) {
+    const targetPath = join6(cwd, ide.skillsDir, skillName);
+    if (!existsSync5(targetPath) || !statSync2(targetPath).isDirectory()) {
+      try {
+        copyDirSync(sourcePath, targetPath);
+        copied++;
+      } catch (err) {
+        throw new Error(`Could not sync "${skillName}" to ${ide.name}: ${err.message}`, {
+          cause: err
+        });
+      }
+    }
+  }
+  return copied;
+}
+
+// src/lib/state.js
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
+import { join as join7 } from "path";
+var STATE_DIR = ".skill-rules";
+var STATE_FILE = "state.json";
+function statePath(cwd) {
+  return join7(cwd, STATE_DIR, STATE_FILE);
+}
+function readState(cwd) {
+  const p = statePath(cwd);
+  if (!existsSync6(p)) return {};
+  try {
+    return JSON.parse(readFileSync4(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeState(state, cwd) {
+  mkdirSync2(join7(cwd, STATE_DIR), { recursive: true });
+  writeFileSync4(statePath(cwd), JSON.stringify(state, null, 2) + "\n");
+}
+function getActiveStage(cwd = process.cwd()) {
+  return readState(cwd).activeStage ?? null;
+}
+function setActiveStage(stage, cwd = process.cwd()) {
+  const state = readState(cwd);
+  state.activeStage = stage;
+  writeState(state, cwd);
+}
+function clearActiveStage(cwd = process.cwd()) {
+  const state = readState(cwd);
+  delete state.activeStage;
+  writeState(state, cwd);
+}
+
+// src/ui.jsx
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import figures from "figures";
+var STATUS_ICON = {
+  ok: figures.tick,
+  success: figures.tick,
+  missing: figures.cross,
+  error: figures.cross,
+  synced: figures.bullet,
+  warning: figures.warning,
+  info: figures.info
+};
+var STATUS_COLOR = {
+  ok: "green",
+  success: "green",
+  missing: "red",
+  error: "red",
+  synced: "yellow",
+  warning: "yellow",
+  info: "cyan"
+};
+function Header({ children }) {
+  return /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, children));
+}
+function IDEItem({ ide }) {
+  return /* @__PURE__ */ React.createElement(Box, { gap: 2 }, /* @__PURE__ */ React.createElement(Text, { color: "green" }, figures.tick), /* @__PURE__ */ React.createElement(Text, null, ide.name), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, ide.skillsDir));
+}
+function SkillStatus({ name, status, detail }) {
+  return /* @__PURE__ */ React.createElement(Box, { gap: 1 }, /* @__PURE__ */ React.createElement(Text, { color: STATUS_COLOR[status] ?? "white" }, STATUS_ICON[status] ?? figures.bullet), /* @__PURE__ */ React.createElement(Text, { bold: true }, name), detail && /* @__PURE__ */ React.createElement(Text, { dimColor: true }, detail));
+}
+function StatusLine({ variant, children }) {
+  return /* @__PURE__ */ React.createElement(Box, { gap: 1 }, /* @__PURE__ */ React.createElement(Text, { color: STATUS_COLOR[variant] ?? "white" }, STATUS_ICON[variant] ?? figures.bullet), /* @__PURE__ */ React.createElement(Text, null, children));
+}
+function Hint({ children }) {
+  return /* @__PURE__ */ React.createElement(Text, { dimColor: true }, " ", children);
+}
+function ListSelect({ options, onSelect }) {
+  const [index, setIndex] = useState(0);
+  useInput((_, key) => {
+    if (key.upArrow) setIndex((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setIndex((i) => Math.min(options.length - 1, i + 1));
+    else if (key.return) onSelect(options[index].value);
+  });
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, options.map((opt, i) => /* @__PURE__ */ React.createElement(Box, { key: opt.value, gap: 1 }, /* @__PURE__ */ React.createElement(Text, { color: i === index ? "cyan" : void 0 }, i === index ? figures.pointerSmall : " "), /* @__PURE__ */ React.createElement(Text, { color: i === index ? "cyan" : void 0 }, opt.label))));
+}
+
+// src/commands/run.jsx
+async function run(options = {}) {
+  const cwd = process.cwd();
+  const explicitStage = options.stage ?? null;
+  const activeStage = getActiveStage(cwd);
+  const stage = explicitStage ?? activeStage;
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ React2.createElement(RunUI, { stage, stageFromState: !explicitStage && !!activeStage })
+  );
+  await waitUntilExit();
+}
+function RunUI({ stage, stageFromState }) {
+  const { exit } = useApp();
+  const [phase, setPhase] = useState2("init");
+  const [state, setState] = useState2(null);
+  useEffect(() => {
+    try {
+      const cwd = process.cwd();
+      const ides2 = detectIDEs(cwd);
+      const lock = readLock(cwd);
+      const rules = readRules(cwd);
+      if (ides2.length === 0) {
+        setState({
+          error: "No IDE directories detected.\nExpected: .claude/  .cursor/  .windsurf/  .agents/  .openhands/"
+        });
+        setPhase("error");
+        return;
+      }
+      if (stage && rules && !(stage in (rules.stages ?? {}))) {
+        const available = listStages(rules);
+        const hint = stageFromState ? "\nActive stage is stale \u2014 run: skill-rules use --off" : "";
+        setState({
+          error: `Stage "${stage}" not found.${available.length ? `
+Available: ${available.join(", ")}` : "\nNo stages defined yet."}${hint}`
+        });
+        setPhase("error");
+        return;
+      }
+      syncGitignore(cwd, ides2, lock);
+      const activeSkills = getActiveSkills(rules, stage);
+      const lockSkills = Object.keys(lock.skills);
+      const skillsToCheck = stage ? activeSkills : lockSkills;
+      if (skillsToCheck.length === 0) {
+        setState({ ides: ides2, results: [], stage });
+        setPhase("done");
+        return;
+      }
+      const results2 = [];
+      for (const skillName of skillsToCheck) {
+        const sources = findSkillSources(cwd, ides2, skillName);
+        if (sources.length === 0) {
+          results2.push({ name: skillName, status: "missing" });
+        } else if (sources.length < ides2.length) {
+          const copied = syncSkillToMissingIDEs(cwd, ides2, skillName, sources[0]);
+          results2.push({
+            name: skillName,
+            status: "synced",
+            detail: `synced to ${copied} ${copied === 1 ? "IDE" : "IDEs"} from ${sources[0].name}`
+          });
+        } else {
+          results2.push({ name: skillName, status: "ok" });
+        }
+      }
+      setState({ ides: ides2, results: results2, stage });
+      setPhase("done");
+    } catch (err) {
+      setState({ error: err.message });
+      setPhase("error");
+    }
+  }, []);
+  useEffect(() => {
+    if (phase === "done" || phase === "error") exit();
+  }, [phase]);
+  if (phase === "init") return /* @__PURE__ */ React2.createElement(Spinner, { label: "Scanning IDEs and skills\u2026" });
+  if (phase === "error")
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, state.error));
+  const { ides, results, stage: activeStage } = state;
+  if (!results || results.length === 0) {
+    const msg = activeStage ? `Stage [${activeStage}] has no skills. Run: skill-rules add --stage ${activeStage}` : "No skills yet. Run: skill-rules add";
+    return /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, msg);
+  }
+  const ok = results.filter((r) => r.status === "ok");
+  const synced = results.filter((r) => r.status === "synced");
+  const missing = results.filter((r) => r.status === "missing");
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React2.createElement(Header, null, "skill-rules", activeStage ? ` [${activeStage}]` : ""), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "IDEs (", ides.length, ")"), ides.map((ide) => /* @__PURE__ */ React2.createElement(IDEItem, { key: ide.id, ide }))), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "Skills (", results.length, ")"), results.map((r) => /* @__PURE__ */ React2.createElement(SkillStatus, { key: r.name, name: r.name, status: r.status, detail: r.detail }))), /* @__PURE__ */ React2.createElement(Box2, { gap: 3 }, ok.length > 0 && /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, ok.length, " up to date"), synced.length > 0 && /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, synced.length, " synced"), missing.length > 0 && /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, missing.length, " missing \u2014 install via ", /* @__PURE__ */ React2.createElement(Text2, { bold: true }, "skills.sh"), " or", " ", /* @__PURE__ */ React2.createElement(Text2, { bold: true }, "autoskill"))));
+}
+
+// src/commands/init.jsx
+import React3 from "react";
+import { render as render2, Box as Box3, Text as Text3 } from "ink";
+import { existsSync as existsSync7 } from "fs";
+import { join as join8 } from "path";
+async function init() {
+  const cwd = process.cwd();
+  const ides = detectIDEs(cwd);
+  if (ides.length === 0) {
+    const { unmount: unmount2 } = render2(
+      /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(StatusLine, { variant: "warning" }, "No IDE directories detected."), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "Create one of: .claude/ .cursor/ .windsurf/ .agents/ .openhands/"))
+    );
+    unmount2();
+    return;
+  }
+  const lockPath = join8(cwd, "skills-lock.json");
+  const lockExists = existsSync7(lockPath);
+  const rulesPath = join8(cwd, "skills.rules");
+  const rulesExists = existsSync7(rulesPath);
+  if (!lockExists) writeLock({ version: 1, skills: {} }, cwd);
+  if (!rulesExists) writeRules(createEmptyRules(), cwd);
+  const lock = readLock(cwd);
+  const rules = readRules(cwd);
+  syncGitignore(cwd, ides, lock);
+  const skillCount = Object.keys(lock.skills).length;
+  const stages = listStages(rules);
+  const { unmount } = render2(
+    /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Header, null, "skill-rules init"), /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "IDEs detected (", ides.length, ")"), ides.map((ide) => /* @__PURE__ */ React3.createElement(IDEItem, { key: ide.id, ide }))), /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(StatusLine, { variant: lockExists ? "info" : "success" }, "skills-lock.json", lockExists ? ` \u2014 already exists (${skillCount} skill${skillCount !== 1 ? "s" : ""})` : " \u2014 created"), /* @__PURE__ */ React3.createElement(StatusLine, { variant: rulesExists ? "info" : "success" }, "skills.rules", rulesExists ? ` \u2014 already exists (stages: ${stages.join(", ") || "none"})` : " \u2014 created (empty)"), /* @__PURE__ */ React3.createElement(StatusLine, { variant: "success" }, ".gitignore \u2014 updated")), /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Hint, null, "1. Install skills: skills.sh or autoskill"), /* @__PURE__ */ React3.createElement(Hint, null, "2. Assign stages: skill-rules add"), /* @__PURE__ */ React3.createElement(Hint, null, "3. Sync IDEs: npx skill-rules")))
+  );
+  unmount();
+}
+
+// src/commands/add.jsx
+import React4, { useState as useState3, useEffect as useEffect2 } from "react";
+import { render as render3, Box as Box4, Text as Text4, useApp as useApp2 } from "ink";
+import { MultiSelect, TextInput } from "@inkjs/ui";
+var NEW_STAGE = "__new__";
+var STAGE_RE = /^[a-z0-9_-]+$/;
+function normalizeSkillName(skill) {
+  const base = skill.startsWith("@") ? skill.split("/")[1] : skill;
+  return base.replace(/^skill-/, "");
+}
+async function add(skill, options = {}) {
+  const cwd = process.cwd();
+  const stage = options.stage ?? null;
+  const track = options.track ?? false;
+  if (stage) {
+    if (!skill) {
+      const { unmount } = render3(
+        /* @__PURE__ */ React4.createElement(Text4, { color: "red" }, "Usage: skill-rules add ", "<skill>", " --stage ", "<name>")
+      );
+      unmount();
+      return;
+    }
+    runNonInteractive(cwd, normalizeSkillName(skill), stage, track);
+  } else {
+    const preselected = skill ? normalizeSkillName(skill) : null;
+    const { waitUntilExit } = render3(/* @__PURE__ */ React4.createElement(AddWizard, { cwd, preselected }));
+    await waitUntilExit();
+  }
+}
+function runNonInteractive(cwd, skillName, stage, track) {
+  const lock = readLock(cwd);
+  const ides = detectIDEs(cwd);
+  const inLock = !!lock.skills[skillName];
+  const rules = readRules(cwd) ?? createEmptyRules();
+  const existingStages = listStages(rules);
+  const isNewStage = !existingStages.includes(stage);
+  const alreadyInStage = (rules.stages[stage] ?? []).includes(skillName);
+  if (!alreadyInStage) {
+    addSkillToStage(rules, skillName, stage);
+    writeRules(rules, cwd);
+  }
+  if (track && inLock) {
+    setSkillTracked(lock, skillName, true);
+    writeLock(lock, cwd);
+  }
+  if (ides.length > 0) syncGitignore(cwd, ides, lock);
+  const { unmount } = render3(
+    /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Header, null, "skill-rules add ", skillName), /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, !inLock && /* @__PURE__ */ React4.createElement(StatusLine, { variant: "warning" }, skillName, " not in skills-lock.json \u2014 install via skills.sh or autoskill first"), isNewStage && !alreadyInStage && /* @__PURE__ */ React4.createElement(StatusLine, { variant: "info" }, "new stage [", stage, "] created"), /* @__PURE__ */ React4.createElement(StatusLine, { variant: alreadyInStage ? "info" : "success" }, "skills.rules [", stage, "] \u2014 ", alreadyInStage ? "already present" : `added ${skillName}`), track && /* @__PURE__ */ React4.createElement(StatusLine, { variant: inLock ? "success" : "warning" }, "git tracking \u2014 ", inLock ? "now tracked" : "skipped (not in lock)"), ides.length > 0 && /* @__PURE__ */ React4.createElement(StatusLine, { variant: "success" }, ".gitignore \u2014 updated")))
+  );
+  unmount();
+}
+function AddWizard({ cwd, preselected }) {
+  const { exit } = useApp2();
+  const [step, setStep] = useState3("select-skills");
+  const [selectedSkills, setSelectedSkills] = useState3([]);
+  const [stageName, setStageName] = useState3("");
+  const [stageError, setStageError] = useState3("");
+  const [summary, setSummary] = useState3(null);
+  const lock = readLock(cwd);
+  const ides = detectIDEs(cwd);
+  const skillNames = Object.keys(lock.skills);
+  const rules = readRules(cwd) ?? createEmptyRules();
+  const stages = listStages(rules);
+  useEffect2(() => {
+    if (step === "done") exit();
+  }, [step]);
+  if (skillNames.length === 0) {
+    setTimeout(exit, 0);
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(StatusLine, { variant: "warning" }, "No skills installed yet."), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "Install via skills.sh or autoskill, then run skill-rules add."));
+  }
+  const preselectedMissing = preselected && !skillNames.includes(preselected);
+  if (step === "select-skills") {
+    const options = skillNames.map((name) => {
+      const skillStages = stages.filter((s) => (rules?.stages[s] ?? []).includes(name));
+      return {
+        label: `${name.padEnd(20)} ${skillStages.length ? skillStages.join(", ") : "\u2014"}`,
+        value: name
+      };
+    });
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Header, null, "Add skills to stage"), preselectedMissing && /* @__PURE__ */ React4.createElement(StatusLine, { variant: "warning" }, '"', preselected, '" not in skills-lock.json \u2014 install it first'), /* @__PURE__ */ React4.createElement(Box4, { gap: 4 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "SKILL".padEnd(20)), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "CURRENT STAGES")), /* @__PURE__ */ React4.createElement(
+      MultiSelect,
+      {
+        options,
+        defaultValue: preselected && skillNames.includes(preselected) ? [preselected] : [],
+        onSubmit: (values) => {
+          if (values.length === 0) {
+            exit();
+            return;
+          }
+          setSelectedSkills(values);
+          setStep("select-stage");
+        }
+      }
+    ), /* @__PURE__ */ React4.createElement(Hint, null, "Space toggle \xB7 Enter confirm \xB7 0 selected = cancel"));
+  }
+  if (step === "select-stage") {
+    const stageOptions = [
+      ...stages.map((s) => ({ label: s, value: s })),
+      { label: "+ Create new stage\u2026", value: NEW_STAGE }
+    ];
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Header, null, "Select stage"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "Skills: ", /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, selectedSkills.join(", "))), /* @__PURE__ */ React4.createElement(
+      ListSelect,
+      {
+        options: stageOptions,
+        onSelect: (value) => {
+          if (value === NEW_STAGE) {
+            setStep("create-stage");
+          } else {
+            setStageName(value);
+            setStep("confirm-track");
+          }
+        }
+      }
+    ), /* @__PURE__ */ React4.createElement(Hint, null, "\u2191\u2193 navigate \xB7 Enter confirm"));
+  }
+  if (step === "create-stage") {
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Header, null, "New stage name"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "Allowed: letters, numbers, hyphens, underscores"), /* @__PURE__ */ React4.createElement(
+      TextInput,
+      {
+        placeholder: "e.g. dev, qa, staging\u2026",
+        onSubmit: (value) => {
+          const trimmed = value.trim().toLowerCase();
+          if (!trimmed) return;
+          if (!STAGE_RE.test(trimmed)) {
+            setStageError(`"${trimmed}" is invalid \u2014 use only letters, numbers, - and _`);
+            return;
+          }
+          setStageError("");
+          setStageName(trimmed);
+          setStep("confirm-track");
+        }
+      }
+    ), stageError && /* @__PURE__ */ React4.createElement(Text4, { color: "red" }, stageError));
+  }
+  if (step === "confirm-track") {
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Header, null, "Git tracking"), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "Commit skills to git? By default each dev installs their own copy."), /* @__PURE__ */ React4.createElement(
+      ListSelect,
+      {
+        options: [
+          { label: "No \u2014 keep gitignored  (recommended)", value: "no" },
+          { label: "Yes \u2014 commit to repo", value: "yes" }
+        ],
+        onSelect: (value) => {
+          const track = value === "yes";
+          applyChanges(cwd, selectedSkills, stageName, track, lock, rules, ides);
+          setSummary({ skills: selectedSkills, stage: stageName, track });
+          setStep("done");
+        }
+      }
+    ), /* @__PURE__ */ React4.createElement(Hint, null, "\u2191\u2193 navigate \xB7 Enter confirm"));
+  }
+  if (step === "done" && summary) {
+    return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React4.createElement(Header, null, "Done"), summary.skills.map((name) => /* @__PURE__ */ React4.createElement(StatusLine, { key: name, variant: "success" }, name, " \u2192 [", summary.stage, "]", summary.track ? " \xB7 tracked in git" : "")), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "Run npx skill-rules to sync across IDEs."));
+  }
+  return null;
+}
+function applyChanges(cwd, skillNames, stage, track, lock, rules, ides) {
+  for (const name of skillNames) {
+    addSkillToStage(rules, name, stage);
+    if (track && lock.skills[name] !== void 0) {
+      setSkillTracked(lock, name, true);
+    }
+  }
+  writeRules(rules, cwd);
+  if (track) writeLock(lock, cwd);
+  if (ides.length > 0) syncGitignore(cwd, ides, lock);
+}
+
+// src/commands/list.jsx
+import React5, { useState as useState4, useEffect as useEffect3 } from "react";
+import { render as render4, Box as Box5, Text as Text5, useApp as useApp3 } from "ink";
+import { MultiSelect as MultiSelect2 } from "@inkjs/ui";
+async function list(options = {}) {
+  const { waitUntilExit } = render4(/* @__PURE__ */ React5.createElement(ListUI, { track: options.track, untrack: options.untrack }));
+  await waitUntilExit();
+}
+function ListUI({ track, untrack }) {
+  const { exit } = useApp3();
+  const cwd = process.cwd();
+  const lock = readLock(cwd);
+  const rules = readRules(cwd);
+  const ides = detectIDEs(cwd);
+  const skills = Object.entries(lock.skills);
+  const stages = listStages(rules);
+  if (track || untrack) {
+    const skillName = track ?? untrack;
+    const exists = !!lock.skills[skillName];
+    if (!exists) {
+      setTimeout(exit, 0);
+      return /* @__PURE__ */ React5.createElement(Text5, { color: "red" }, '"', skillName, '" not found in skills-lock.json');
+    }
+    setSkillTracked(lock, skillName, !!track);
+    writeLock(lock, cwd);
+    syncGitignore(cwd, ides, lock);
+    setTimeout(exit, 0);
+    return /* @__PURE__ */ React5.createElement(StatusLine, { variant: track ? "success" : "warning" }, track ? "Tracking" : "Ignoring", " ", skillName, track ? " \u2014 will be committed to git" : " \u2014 excluded from git");
+  }
+  if (skills.length === 0) {
+    setTimeout(exit, 0);
+    return /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "No skills yet. Run: skill-rules add");
+  }
+  return /* @__PURE__ */ React5.createElement(
+    InteractiveList,
+    {
+      skills,
+      stages,
+      rules,
+      ides,
+      lock,
+      cwd
+    }
+  );
+}
+function InteractiveList({ skills, stages, rules, ides, lock, cwd }) {
+  const { exit } = useApp3();
+  const [done, setDone] = useState4(false);
+  const [updated, setUpdated] = useState4([]);
+  const initialTracked = skills.filter(([, i]) => i.track).map(([n]) => n);
+  const options = skills.map(([name, info]) => {
+    const sources = findSkillSources(cwd, ides, name);
+    const skillStages = stages.filter((s) => (rules?.stages[s] ?? []).includes(name));
+    const installedLabel = sources.length === 0 ? "not installed" : sources.length === ides.length ? "all IDEs" : sources.map((s) => s.name).join(", ");
+    const stageLabel = skillStages.length > 0 ? skillStages.join(", ") : "\u2014";
+    return {
+      label: `${name.padEnd(18)} ${stageLabel.padEnd(14)} ${installedLabel}`,
+      value: name
+    };
+  });
+  const handleSubmit = (selected) => {
+    const changed = [];
+    for (const [name] of skills) {
+      const wasTracked = !!lock.skills[name].track;
+      const isNowTracked = selected.includes(name);
+      if (wasTracked !== isNowTracked) {
+        setSkillTracked(lock, name, isNowTracked);
+        changed.push({ name, tracked: isNowTracked });
+      }
+    }
+    writeLock(lock, cwd);
+    syncGitignore(cwd, ides, lock);
+    setUpdated(changed);
+    setDone(true);
+  };
+  useEffect3(() => {
+    if (done) exit();
+  }, [done]);
+  if (done) {
+    if (updated.length === 0) return /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "No changes.");
+    return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React5.createElement(Header, null, "Updated git tracking"), updated.map(({ name, tracked }) => /* @__PURE__ */ React5.createElement(StatusLine, { key: name, variant: tracked ? "success" : "warning" }, name, " \u2014 ", tracked ? "now tracked (committed to git)" : "now gitignored")));
+  }
+  return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React5.createElement(Header, null, "Skills"), /* @__PURE__ */ React5.createElement(Box5, { gap: 4 }, /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "SKILL".padEnd(18)), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "STAGES".padEnd(14)), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "INSTALLED")), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "Select skills to ", /* @__PURE__ */ React5.createElement(Text5, { color: "green" }, "track in git"), " (checked = committed, unchecked = gitignored)"), /* @__PURE__ */ React5.createElement(MultiSelect2, { options, defaultValue: initialTracked, onSubmit: handleSubmit }), /* @__PURE__ */ React5.createElement(Hint, null, "Space to toggle \xB7 Enter to confirm \xB7 tracked skills won't be in .gitignore"));
+}
+
+// src/commands/ignore.jsx
+import React6 from "react";
+import { render as render5, Box as Box6, Text as Text6 } from "ink";
+import figures2 from "figures";
+async function ignore() {
+  const cwd = process.cwd();
+  const ides = detectIDEs(cwd);
+  if (ides.length === 0) {
+    const { unmount: unmount2 } = render5(
+      /* @__PURE__ */ React6.createElement(StatusLine, { variant: "warning" }, "No IDE directories detected. Nothing to ignore.")
+    );
+    unmount2();
+    return;
+  }
+  const lock = readLock(cwd);
+  const tracked = Object.entries(lock.skills).filter(([, i]) => i.track).map(([n]) => n);
+  const patterns = buildIgnorePatterns(ides, tracked);
+  updateGitignore(cwd, patterns);
+  const { unmount } = render5(
+    /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React6.createElement(Header, null, ".gitignore updated"), /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column" }, patterns.map((p) => /* @__PURE__ */ React6.createElement(Box6, { key: p, gap: 2 }, /* @__PURE__ */ React6.createElement(Text6, { color: p.startsWith("!") ? "green" : "yellow" }, p.startsWith("!") ? figures2.tick : figures2.pointerSmall), /* @__PURE__ */ React6.createElement(Text6, null, p)))))
+  );
+  unmount();
+}
+
+// src/commands/help.jsx
+import React7 from "react";
+import { render as render6, Box as Box7, Text as Text7 } from "ink";
+var COMMANDS = [
+  { cmd: "sr", desc: "Sync all active skills across every detected IDE" },
+  { cmd: "sr init", desc: "Create config files and update .gitignore" },
+  { cmd: "sr add [skill]", desc: "Assign skills to stages" },
+  { cmd: "sr remove [skill]", desc: "Remove skill-to-stage assignments" },
+  { cmd: "sr use [stage]", desc: "Activate a stage \u2014 stash / restore skills" },
+  { cmd: "sr use --off", desc: "Restore all stashed skills, clear active stage" },
+  { cmd: "sr list", desc: "Manage git tracking for skills" },
+  { cmd: "sr ignore", desc: "Regenerate .gitignore skill-rules block" },
+  { cmd: "sr help", desc: "Show this help" }
+];
+var OPTIONS = [
+  { flag: "--stage <name>", desc: "Limit sync to a specific stage" },
+  { flag: "--version", desc: "Show version number" },
+  { flag: "<command> --help", desc: "Show detailed help for a command" }
+];
+var CMD_W = Math.max(...COMMANDS.map((c) => c.cmd.length)) + 2;
+var OPT_W = Math.max(...OPTIONS.map((o) => o.flag.length)) + 2;
+async function help() {
+  const { unmount } = render6(/* @__PURE__ */ React7.createElement(HelpUI, null));
+  unmount();
+}
+function HelpUI() {
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React7.createElement(Header, null, "skill-rules"), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, "Sync AI agent skills across IDEs with per-stage rules"), /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text7, { bold: true }, "Commands"), COMMANDS.map(({ cmd, desc }) => /* @__PURE__ */ React7.createElement(Box7, { key: cmd, gap: 2 }, /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, cmd.padEnd(CMD_W)), /* @__PURE__ */ React7.createElement(Text7, null, desc)))), /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text7, { bold: true }, "Options"), OPTIONS.map(({ flag, desc }) => /* @__PURE__ */ React7.createElement(Box7, { key: flag, gap: 2 }, /* @__PURE__ */ React7.createElement(Text7, { color: "yellow" }, flag.padEnd(OPT_W)), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, desc)))), /* @__PURE__ */ React7.createElement(Hint, null, "https://github.com/carrilloapps/skill-rules"));
+}
+
+// src/commands/remove.jsx
+import React8, { useState as useState5, useEffect as useEffect4 } from "react";
+import { render as render7, Box as Box8, Text as Text8, useApp as useApp4 } from "ink";
+import { MultiSelect as MultiSelect3 } from "@inkjs/ui";
+var ALL_STAGES = "__all__";
+async function remove(skill, options = {}) {
+  const cwd = process.cwd();
+  const stage = options.stage ?? null;
+  if (skill) {
+    runNonInteractive2(cwd, skill, stage);
+  } else {
+    const { waitUntilExit } = render7(/* @__PURE__ */ React8.createElement(RemoveWizard, { cwd }));
+    await waitUntilExit();
+  }
+}
+function runNonInteractive2(cwd, skillName, stage) {
+  const rules = readRules(cwd);
+  if (!rules) {
+    const { unmount: unmount2 } = render7(
+      /* @__PURE__ */ React8.createElement(StatusLine, { variant: "warning" }, "No skills.rules found. Nothing to remove.")
+    );
+    unmount2();
+    return;
+  }
+  const stages = listStages(rules);
+  const inAnyStage = stages.some((s) => (rules.stages[s] ?? []).includes(skillName));
+  if (!inAnyStage) {
+    const { unmount: unmount2 } = render7(
+      /* @__PURE__ */ React8.createElement(StatusLine, { variant: "warning" }, '"', skillName, '" is not assigned to any stage.')
+    );
+    unmount2();
+    return;
+  }
+  if (stage && !(rules.stages[stage] ?? []).includes(skillName)) {
+    const assignedTo = stages.filter((s) => (rules.stages[s] ?? []).includes(skillName));
+    const { unmount: unmount2 } = render7(
+      /* @__PURE__ */ React8.createElement(StatusLine, { variant: "warning" }, '"', skillName, '" is not in [', stage, "]. Assigned to: ", assignedTo.join(", "))
+    );
+    unmount2();
+    return;
+  }
+  removeSkillFromStage(rules, skillName, stage ?? null);
+  writeRules(rules, cwd);
+  const lock = readLock(cwd);
+  const ides = detectIDEs(cwd);
+  if (ides.length > 0) syncGitignore(cwd, ides, lock);
+  const { unmount } = render7(
+    /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React8.createElement(Header, null, "skill-rules remove ", skillName), /* @__PURE__ */ React8.createElement(StatusLine, { variant: "success" }, "Removed from ", stage ? `[${stage}]` : "all stages"), ides.length > 0 && /* @__PURE__ */ React8.createElement(StatusLine, { variant: "success" }, ".gitignore \u2014 updated"))
+  );
+  unmount();
+}
+function RemoveWizard({ cwd }) {
+  const { exit } = useApp4();
+  const [step, setStep] = useState5("select-skills");
+  const [selectedSkills, setSelectedSkills] = useState5([]);
+  const [summary, setSummary] = useState5(null);
+  const lock = readLock(cwd);
+  const ides = detectIDEs(cwd);
+  const rules = readRules(cwd) ?? { version: 1, stages: {} };
+  const stages = listStages(rules);
+  const stagedSkills = [...new Set(Object.values(rules.stages).flat())];
+  useEffect4(() => {
+    if (step === "done") exit();
+  }, [step]);
+  if (stagedSkills.length === 0) {
+    setTimeout(exit, 0);
+    return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React8.createElement(StatusLine, { variant: "warning" }, "No skills are assigned to any stage."), /* @__PURE__ */ React8.createElement(Text8, { dimColor: true }, "Use skill-rules add to assign skills to stages first."));
+  }
+  if (step === "select-skills") {
+    const options = stagedSkills.map((name) => {
+      const skillStages = stages.filter((s) => (rules.stages[s] ?? []).includes(name));
+      return {
+        label: `${name.padEnd(20)} ${skillStages.join(", ")}`,
+        value: name
+      };
+    });
+    return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React8.createElement(Header, null, "Remove from stage"), /* @__PURE__ */ React8.createElement(Box8, { gap: 4 }, /* @__PURE__ */ React8.createElement(Text8, { dimColor: true }, "SKILL".padEnd(20)), /* @__PURE__ */ React8.createElement(Text8, { dimColor: true }, "ASSIGNED STAGES")), /* @__PURE__ */ React8.createElement(
+      MultiSelect3,
+      {
+        options,
+        onSubmit: (values) => {
+          if (values.length === 0) {
+            exit();
+            return;
+          }
+          setSelectedSkills(values);
+          setStep("select-stage");
+        }
+      }
+    ), /* @__PURE__ */ React8.createElement(Hint, null, "Space toggle \xB7 Enter confirm \xB7 0 selected = cancel"));
+  }
+  if (step === "select-stage") {
+    const relevantStages = stages.filter(
+      (s) => selectedSkills.some((skill) => (rules.stages[s] ?? []).includes(skill))
+    );
+    const stageOptions = [
+      ...relevantStages.map((s) => ({ label: s, value: s })),
+      { label: "All stages", value: ALL_STAGES }
+    ];
+    return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React8.createElement(Header, null, "Remove from which stage?"), /* @__PURE__ */ React8.createElement(Text8, { dimColor: true }, "Skills: ", /* @__PURE__ */ React8.createElement(Text8, { color: "cyan" }, selectedSkills.join(", "))), /* @__PURE__ */ React8.createElement(
+      ListSelect,
+      {
+        options: stageOptions,
+        onSelect: (value) => {
+          const stage = value === ALL_STAGES ? null : value;
+          applyRemove(cwd, selectedSkills, stage, rules, lock, ides);
+          setSummary({ skills: selectedSkills, stage: value });
+          setStep("done");
+        }
+      }
+    ), /* @__PURE__ */ React8.createElement(Hint, null, "\u2191\u2193 navigate \xB7 Enter confirm"));
+  }
+  if (step === "done" && summary) {
+    return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React8.createElement(Header, null, "Done"), summary.skills.map((name) => /* @__PURE__ */ React8.createElement(StatusLine, { key: name, variant: "success" }, name, " removed from ", summary.stage === ALL_STAGES ? "all stages" : `[${summary.stage}]`)), /* @__PURE__ */ React8.createElement(Text8, { dimColor: true }, "Run skill-rules list to manage git tracking."));
+  }
+  return null;
+}
+function applyRemove(cwd, skillNames, stage, rules, lock, ides) {
+  for (const name of skillNames) {
+    removeSkillFromStage(rules, name, stage);
+  }
+  writeRules(rules, cwd);
+  if (ides.length > 0) syncGitignore(cwd, ides, lock);
+}
+
+// src/commands/use.jsx
+import React9, { useState as useState6, useEffect as useEffect5 } from "react";
+import { render as render8, Box as Box9, Text as Text9, useApp as useApp5 } from "ink";
+import { existsSync as existsSync9 } from "fs";
+import { join as join10 } from "path";
+
+// src/lib/stash.js
+import { existsSync as existsSync8, statSync as statSync3, readdirSync as readdirSync2, mkdirSync as mkdirSync3, rmSync } from "fs";
+import { join as join9 } from "path";
+var STASH_DIR = ".skill-rules/stash";
+function stashSkillPath(cwd, skillName) {
+  return join9(cwd, STASH_DIR, skillName);
+}
+function isStashed(cwd, skillName) {
+  const p = stashSkillPath(cwd, skillName);
+  return existsSync8(p) && statSync3(p).isDirectory();
+}
+function listStashed(cwd) {
+  const stashDir = join9(cwd, STASH_DIR);
+  if (!existsSync8(stashDir)) return [];
+  return readdirSync2(stashDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+function stashSkill(cwd, ides, skillName) {
+  const dest = stashSkillPath(cwd, skillName);
+  if (existsSync8(dest)) return;
+  const source = ides.find((ide) => {
+    const p = join9(cwd, ide.skillsDir, skillName);
+    return existsSync8(p) && statSync3(p).isDirectory();
+  });
+  if (source) {
+    mkdirSync3(join9(cwd, STASH_DIR), { recursive: true });
+    copyDirSync(join9(cwd, source.skillsDir, skillName), dest);
+  }
+  for (const ide of ides) {
+    const p = join9(cwd, ide.skillsDir, skillName);
+    if (existsSync8(p)) rmSync(p, { recursive: true, force: true });
+  }
+}
+function restoreSkill(cwd, ides, skillName) {
+  const src = stashSkillPath(cwd, skillName);
+  if (!existsSync8(src)) return;
+  for (const ide of ides) {
+    const ideSkillsDir = join9(cwd, ide.skillsDir);
+    const targetPath = join9(ideSkillsDir, skillName);
+    if (!existsSync8(targetPath)) {
+      mkdirSync3(ideSkillsDir, { recursive: true });
+      copyDirSync(src, targetPath);
+    }
+  }
+  rmSync(src, { recursive: true, force: true });
+}
+
+// src/commands/use.jsx
+async function use(stage, options = {}) {
+  const cwd = process.cwd();
+  const { waitUntilExit } = render8(
+    /* @__PURE__ */ React9.createElement(UseWizard, { cwd, stage: stage ?? null, off: options.off ?? false })
+  );
+  await waitUntilExit();
+}
+function buildPlan(cwd, stage, ides, lock, rules) {
+  const targetSkills = new Set(rules.stages[stage] ?? []);
+  const allStagedSkills = new Set(getActiveSkills(rules, null));
+  const trackedSkills = new Set(
+    Object.entries(lock.skills ?? {}).filter(([, info]) => info.track).map(([name]) => name)
+  );
+  const toActivate = [];
+  const toRestore = [];
+  const toMissing = [];
+  const toStash = [];
+  const toSkip = [];
+  for (const skill of allStagedSkills) {
+    if (trackedSkills.has(skill)) {
+      toSkip.push(skill);
+      continue;
+    }
+    if (targetSkills.has(skill)) {
+      if (isStashed(cwd, skill)) {
+        toRestore.push(skill);
+      } else {
+        const inIDEs = ides.some((ide) => existsSync9(join10(cwd, ide.skillsDir, skill)));
+        if (inIDEs) toActivate.push(skill);
+        else toMissing.push(skill);
+      }
+    } else {
+      if (!isStashed(cwd, skill)) {
+        const inIDEs = ides.some((ide) => existsSync9(join10(cwd, ide.skillsDir, skill)));
+        if (inIDEs) toStash.push(skill);
+      }
+    }
+  }
+  return { toActivate, toRestore, toMissing, toStash, toSkip };
+}
+function executePlan(cwd, stage, ides, lock, plan) {
+  for (const skill of plan.toStash) stashSkill(cwd, ides, skill);
+  for (const skill of plan.toRestore) restoreSkill(cwd, ides, skill);
+  setActiveStage(stage, cwd);
+  syncGitignore(cwd, ides, lock);
+}
+function UseWizard({ cwd, stage, off }) {
+  const { exit } = useApp5();
+  const [step, setStep] = useState6("init");
+  const [data, setData] = useState6(null);
+  useEffect5(() => {
+    const ides = detectIDEs(cwd);
+    const lock = readLock(cwd);
+    const currentStage = getActiveStage(cwd);
+    if (!stage && !off) {
+      const stashed = listStashed(cwd);
+      const rules2 = readRules(cwd);
+      setData({ mode: "status", currentStage, stashed, rules: rules2 });
+      setStep("done");
+      return;
+    }
+    if (off) {
+      const stashed = listStashed(cwd);
+      if (stashed.length === 0) {
+        clearActiveStage(cwd);
+        setData({ mode: "off", stashed: [] });
+        setStep("done");
+        return;
+      }
+      if (ides.length === 0) {
+        setData({
+          mode: "error",
+          error: "No IDE directories detected \u2014 cannot restore stashed skills."
+        });
+        setStep("done");
+        return;
+      }
+      try {
+        for (const skill of stashed) restoreSkill(cwd, ides, skill);
+        clearActiveStage(cwd);
+        syncGitignore(cwd, ides, lock);
+        setData({ mode: "off", stashed });
+      } catch (err) {
+        setData({ mode: "error", error: err.message });
+      }
+      setStep("done");
+      return;
+    }
+    if (ides.length === 0) {
+      setData({
+        mode: "error",
+        error: "No IDE directories detected.\nExpected: .claude/  .cursor/  .windsurf/  .agents/  .openhands/"
+      });
+      setStep("done");
+      return;
+    }
+    const rules = readRules(cwd);
+    if (!rules) {
+      setData({ mode: "error", error: "No skills.rules found. Run: skill-rules init" });
+      setStep("done");
+      return;
+    }
+    const available = listStages(rules);
+    if (!available.includes(stage)) {
+      setData({
+        mode: "error",
+        error: `Stage "${stage}" not found.${available.length ? `
+Available: ${available.join(", ")}` : "\nNo stages defined yet."}`
+      });
+      setStep("done");
+      return;
+    }
+    if (currentStage === stage) {
+      setData({ mode: "already", stage });
+      setStep("done");
+      return;
+    }
+    const plan = buildPlan(cwd, stage, ides, lock, rules);
+    if (plan.toStash.length === 0) {
+      try {
+        executePlan(cwd, stage, ides, lock, plan);
+        setData({ mode: "use", stage, plan });
+      } catch (err) {
+        setData({ mode: "error", error: err.message });
+      }
+      setStep("done");
+      return;
+    }
+    setData({ mode: "use", stage, plan, ides, lock });
+    setStep("confirm");
+  }, []);
+  useEffect5(() => {
+    if (step === "done") exit();
+  }, [step]);
+  if (step === "confirm" && data) {
+    const { plan, stage: targetStage, ides: ideList, lock: lockData } = data;
+    return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React9.createElement(Header, null, "skill-rules use ", targetStage), /* @__PURE__ */ React9.createElement(PlanPreview, { plan }), /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, 'Skills marked "stash" will be removed from IDEs and saved locally.'), /* @__PURE__ */ React9.createElement(
+      ListSelect,
+      {
+        options: [
+          { label: "Yes, activate stage", value: "yes" },
+          { label: "Cancel", value: "no" }
+        ],
+        onSelect: (value) => {
+          if (value === "no") {
+            exit();
+            return;
+          }
+          try {
+            executePlan(cwd, targetStage, ideList, lockData, plan);
+            setStep("done");
+          } catch (err) {
+            setData((d) => ({ ...d, mode: "error", error: err.message }));
+            setStep("done");
+          }
+        }
+      }
+    ), /* @__PURE__ */ React9.createElement(Hint, null, "\u2191\u2193 navigate \xB7 Enter confirm"));
+  }
+  if (step === "done" && data) {
+    return /* @__PURE__ */ React9.createElement(DoneView, { data });
+  }
+  return null;
+}
+function PlanPreview({ plan }) {
+  const { toActivate, toRestore, toMissing, toStash, toSkip } = plan;
+  return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column" }, toActivate.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "ok" }, "keep    ", " ", s)), toRestore.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "success" }, "restore ", " ", s, /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, " (from stash)"))), toMissing.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "warning" }, "missing ", " ", s, /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, " (not installed)"))), toStash.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "warning" }, "stash   ", " ", s)), toSkip.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "info" }, "skip    ", " ", s, /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, " (tracked in git)"))));
+}
+function DoneView({ data }) {
+  const { mode } = data;
+  if (mode === "error") {
+    return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React9.createElement(Text9, { color: "red" }, data.error));
+  }
+  if (mode === "already") {
+    return /* @__PURE__ */ React9.createElement(StatusLine, { variant: "info" }, "Stage [", data.stage, "] is already active.");
+  }
+  if (mode === "off") {
+    const { stashed } = data;
+    if (stashed.length === 0) {
+      return /* @__PURE__ */ React9.createElement(StatusLine, { variant: "info" }, "Nothing stashed \u2014 no active stage to clear.");
+    }
+    return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React9.createElement(Header, null, "Done"), stashed.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "success" }, "restored ", s)), /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "No active stage \u2014 all skills available."));
+  }
+  if (mode === "status") {
+    const { currentStage, stashed, rules } = data;
+    const stages = listStages(rules ?? { stages: {} });
+    if (!currentStage) {
+      return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React9.createElement(StatusLine, { variant: "info" }, "No active stage \u2014 all skills available."), stages.length > 0 && /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "Run: skill-rules use ", "<stage>", " to activate one"));
+    }
+    return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React9.createElement(Header, null, "skill-rules use"), /* @__PURE__ */ React9.createElement(StatusLine, { variant: "success" }, "Active stage: [", currentStage, "]"), stashed.length > 0 && /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "Stashed (", stashed.length, "): ", stashed.join(", ")), /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "Run: skill-rules use --off to restore all"));
+  }
+  if (mode === "use") {
+    const { plan, stage } = data;
+    const { toActivate, toRestore, toMissing, toStash, toSkip } = plan;
+    return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React9.createElement(Header, null, "Done"), toActivate.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "ok" }, "active ", s)), toRestore.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "success" }, "restored ", s)), toStash.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "warning" }, "stashed ", s)), toMissing.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "warning" }, "missing ", s, /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, " \u2014 install via skills.sh or autoskill"))), toSkip.map((s) => /* @__PURE__ */ React9.createElement(StatusLine, { key: s, variant: "info" }, "tracked ", s)), /* @__PURE__ */ React9.createElement(Text9, { dimColor: true }, "Active stage: [", stage, "] \xB7 Run skill-rules to sync IDEs"));
+  }
+  return null;
+}
+
+// src/cli.jsx
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var { version } = JSON.parse(readFileSync5(join11(__dirname, "../package.json"), "utf8"));
+var stageOption = ["-s, --stage <stage>", "limit to a specific stage (e.g. dev, qa)"];
+function createCli() {
+  const program = new Command();
+  program.name("skill-rules").description("Sync AI agent skills across IDEs and manage per-stage skill rules").version(version).enablePositionalOptions().addHelpCommand(false).option(...stageOption).action((options) => run(options));
+  program.command("init").description("Create skills-lock.json, skills.rules, and update .gitignore").action(init);
+  program.command("add [skill]").description("Assign skills to stages \u2014 interactive when called with no arguments").option(...stageOption).option("--track", "mark skill as tracked in git (default: gitignored)").action(add);
+  program.command("remove [skill]").description("Remove skills from stages \u2014 interactive when called with no arguments").option(...stageOption).action(remove);
+  program.command("list").description("Show and manage skills \u2014 track/untrack from git interactively").option("--track <skill>", "commit a skill to git (remove from .gitignore)").option("--untrack <skill>", "exclude a skill from git (back to .gitignore)").action(list);
+  program.command("ignore").description("Regenerate .gitignore for detected IDE skill directories").action(ignore);
+  program.command("use [stage]").description("Activate a stage \u2014 stashes skills not in it, restores those that are").option("--off", "restore all stashed skills and clear the active stage").action(use);
+  program.command("help").description("Show help for all commands").action(help);
+  return program;
+}
+
+// src/index.jsx
+createCli().parseAsync(process.argv).catch((err) => {
+  console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+  process.exit(1);
+});