@hiver/skills 1.0.1

package/dist/cli.js

@@ -0,0 +1,990 @@
+#!/usr/bin/env node
+
+// src/cli.jsx
+import React10 from "react";
+import { render, Box as Box9, Text as Text10 } from "ink";
+
+// src/commands/Add.jsx
+import React4, { useState as useState3, useEffect } from "react";
+import { Box as Box3, Text as Text4, useApp } from "ink";
+
+// src/components/Select.jsx
+import React, { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Select({ items, onSelect, onBack, message }) {
+  const [cursor, setCursor] = useState(0);
+  useInput((_input, key) => {
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : items.length - 1);
+    }
+    if (key.downArrow) {
+      setCursor((prev) => prev < items.length - 1 ? prev + 1 : 0);
+    }
+    if (key.return) {
+      onSelect(items[cursor].value);
+    }
+    if (key.escape && onBack) {
+      onBack();
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
+      "? ",
+      message,
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        " (\u2191\u2193 move, enter select",
+        onBack ? ", esc back" : "",
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: items.map((item, idx) => {
+      const isActive = idx === cursor;
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: isActive ? "  \u276F " : "    " }),
+        /* @__PURE__ */ jsx(Text, { color: isActive ? "yellow" : "white", bold: isActive, children: item.label })
+      ] }, item.value);
+    }) })
+  ] });
+}
+
+// src/components/MultiSelect.jsx
+import React2, { useState as useState2 } from "react";
+import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function MultiSelect({ items, onSubmit, onBack, message }) {
+  const [cursor, setCursor] = useState2(0);
+  const [selected, setSelected] = useState2(
+    new Set(items.filter((i) => i.checked).map((_, idx) => idx))
+  );
+  useInput2((input, key) => {
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : items.length - 1);
+    }
+    if (key.downArrow) {
+      setCursor((prev) => prev < items.length - 1 ? prev + 1 : 0);
+    }
+    if (input === " ") {
+      setSelected((prev) => {
+        const next = new Set(prev);
+        if (next.has(cursor)) {
+          next.delete(cursor);
+        } else {
+          next.add(cursor);
+        }
+        return next;
+      });
+    }
+    if (key.return) {
+      const result = items.filter((_, idx) => selected.has(idx)).map((i) => i.value);
+      onSubmit(result);
+    }
+    if (key.escape && onBack) {
+      onBack();
+    }
+  });
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "cyan", children: [
+      "? ",
+      message,
+      /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+        " (\u2191\u2193 move, space select, enter confirm",
+        onBack ? ", esc back" : "",
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: items.map((item, idx) => {
+      const isActive = idx === cursor;
+      const isSelected = selected.has(idx);
+      const pointer = isActive ? "\u276F" : " ";
+      const check = isSelected ? "\u25C9" : "\u25EF";
+      const checkColor = isSelected ? "green" : "gray";
+      return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: item.description ? 1 : 0, children: [
+        /* @__PURE__ */ jsxs2(Box2, { children: [
+          /* @__PURE__ */ jsxs2(Text2, { color: isActive ? "cyan" : void 0, children: [
+            pointer,
+            " "
+          ] }),
+          /* @__PURE__ */ jsxs2(Text2, { color: checkColor, children: [
+            check,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx2(Text2, { color: isActive ? "yellow" : "white", bold: true, children: item.label })
+        ] }),
+        item.description && /* @__PURE__ */ jsxs2(Text2, { color: isActive ? "cyan" : "gray", children: [
+          "      ",
+          item.description
+        ] })
+      ] }, item.value);
+    }) })
+  ] });
+}
+
+// src/components/StatusMessage.jsx
+import React3 from "react";
+import { Text as Text3 } from "ink";
+import { jsxs as jsxs3 } from "react/jsx-runtime";
+function Success({ children }) {
+  return /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
+    "\u2713 ",
+    children
+  ] });
+}
+function Warning({ children }) {
+  return /* @__PURE__ */ jsxs3(Text3, { color: "yellow", children: [
+    "\u26A0 ",
+    children
+  ] });
+}
+function ErrorMsg({ children }) {
+  return /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+    "\u2717 ",
+    children
+  ] });
+}
+function Info({ children }) {
+  return /* @__PURE__ */ jsxs3(Text3, { color: "cyan", children: [
+    "\u2139 ",
+    children
+  ] });
+}
+
+// src/utils/targets.js
+var targets = {
+  claude: {
+    name: "Claude Code",
+    skillsDir: ".claude/skills",
+    agentsDir: ".claude/agents"
+  },
+  cursor: {
+    name: "Cursor",
+    skillsDir: ".cursor/rules",
+    agentsDir: ".cursor/rules"
+  },
+  windsurf: {
+    name: "Windsurf",
+    skillsDir: ".windsurfrules",
+    agentsDir: ".windsurfrules"
+  }
+};
+var targetList = Object.entries(targets).map(([key, t]) => ({
+  label: t.name,
+  value: key
+}));
+
+// src/utils/collections.js
+import path from "path";
+import fs from "fs-extra";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var COLLECTIONS_DIR = path.resolve(__dirname, "../collections");
+function getCollectionsDir() {
+  return COLLECTIONS_DIR;
+}
+function listCollections() {
+  if (!fs.existsSync(COLLECTIONS_DIR)) return [];
+  return fs.readdirSync(COLLECTIONS_DIR).filter(
+    (name) => fs.statSync(path.join(COLLECTIONS_DIR, name)).isDirectory()
+  );
+}
+function scanCollection(collectionName) {
+  const collectionDir = path.join(COLLECTIONS_DIR, collectionName);
+  const result = { skills: [], agents: [] };
+  const skillsDir = path.join(collectionDir, "skills");
+  if (fs.existsSync(skillsDir)) {
+    result.skills = fs.readdirSync(skillsDir).filter(
+      (name) => fs.statSync(path.join(skillsDir, name)).isDirectory()
+    );
+  }
+  const agentsDir = path.join(collectionDir, "agents");
+  if (fs.existsSync(agentsDir)) {
+    result.agents = fs.readdirSync(agentsDir).filter((name) => name.endsWith(".md")).map((name) => name.replace(".md", ""));
+  }
+  return result;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    let val = line.slice(idx + 1).trim();
+    if (val.startsWith("[") && val.endsWith("]")) {
+      val = val.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    fm[key] = val;
+  }
+  return fm;
+}
+function getSkillMeta(collectionName, skillName) {
+  const skillFile = path.join(COLLECTIONS_DIR, collectionName, "skills", skillName, "SKILL.md");
+  if (!fs.existsSync(skillFile)) return { description: "", dependencies: [] };
+  const content = fs.readFileSync(skillFile, "utf-8");
+  const fm = parseFrontmatter(content);
+  return {
+    description: fm.description || "",
+    dependencies: Array.isArray(fm.dependencies) ? fm.dependencies : []
+  };
+}
+function getAgentMeta(collectionName, agentName) {
+  const agentFile = path.join(COLLECTIONS_DIR, collectionName, "agents", `${agentName}.md`);
+  if (!fs.existsSync(agentFile)) return { description: "", dependencies: [] };
+  const content = fs.readFileSync(agentFile, "utf-8");
+  const fm = parseFrontmatter(content);
+  return {
+    description: fm.description || "",
+    dependencies: Array.isArray(fm.dependencies) ? fm.dependencies : []
+  };
+}
+function resolveDependencies(selected, selectedCollections) {
+  const installedNames = /* @__PURE__ */ new Set([
+    ...selected.skills.map((s) => s.name),
+    ...selected.agents.map((a) => a.name)
+  ]);
+  const extra = { skills: [], agents: [] };
+  const allItems = [
+    ...selected.skills.map((s) => ({ ...s, type: "skill" })),
+    ...selected.agents.map((a) => ({ ...a, type: "agent" }))
+  ];
+  for (const item of allItems) {
+    const meta = item.type === "skill" ? getSkillMeta(item.collection, item.name) : getAgentMeta(item.collection, item.name);
+    for (const dep of meta.dependencies) {
+      if (installedNames.has(dep)) continue;
+      const searchOrder = [.../* @__PURE__ */ new Set([...selectedCollections, ...listCollections()])];
+      for (const col of searchOrder) {
+        const { skills, agents } = scanCollection(col);
+        if (skills.includes(dep)) {
+          extra.skills.push({ collection: col, name: dep });
+          installedNames.add(dep);
+          break;
+        }
+        if (agents.includes(dep)) {
+          extra.agents.push({ collection: col, name: dep });
+          installedNames.add(dep);
+          break;
+        }
+      }
+    }
+  }
+  return extra;
+}
+
+// src/utils/installer.js
+import path2 from "path";
+import fs2 from "fs-extra";
+async function installSkill(collectionName, skillName, targetConfig, destRoot) {
+  const src = path2.join(getCollectionsDir(), collectionName, "skills", skillName);
+  const dest = path2.join(destRoot, targetConfig.skillsDir, skillName);
+  if (!fs2.existsSync(src)) return false;
+  await fs2.ensureDir(path2.dirname(dest));
+  await fs2.copy(src, dest, { overwrite: true });
+  return true;
+}
+async function installAgent(collectionName, agentName, targetConfig, destRoot) {
+  const src = path2.join(getCollectionsDir(), collectionName, "agents", `${agentName}.md`);
+  const dest = path2.join(destRoot, targetConfig.agentsDir, `${agentName}.md`);
+  if (!fs2.existsSync(src)) return false;
+  await fs2.ensureDir(path2.dirname(dest));
+  await fs2.copy(src, dest, { overwrite: true });
+  return true;
+}
+function listInstalled(targetConfig, destRoot) {
+  const result = { skills: [], agents: [] };
+  const skillsDir = path2.join(destRoot, targetConfig.skillsDir);
+  if (fs2.existsSync(skillsDir)) {
+    result.skills = fs2.readdirSync(skillsDir).filter((name) => {
+      const p = path2.join(skillsDir, name);
+      return fs2.statSync(p).isDirectory() && fs2.existsSync(path2.join(p, "SKILL.md"));
+    });
+  }
+  const agentsDir = path2.join(destRoot, targetConfig.agentsDir);
+  if (fs2.existsSync(agentsDir)) {
+    result.agents = fs2.readdirSync(agentsDir).filter((name) => name.endsWith(".md")).map((name) => name.replace(".md", ""));
+  }
+  return result;
+}
+async function removeSkill(skillName, targetConfig, destRoot) {
+  const skillPath = path2.join(destRoot, targetConfig.skillsDir, skillName);
+  if (fs2.existsSync(skillPath)) {
+    await fs2.remove(skillPath);
+    return true;
+  }
+  return false;
+}
+async function removeAgent(agentName, targetConfig, destRoot) {
+  const agentPath = path2.join(destRoot, targetConfig.agentsDir, `${agentName}.md`);
+  if (fs2.existsSync(agentPath)) {
+    await fs2.remove(agentPath);
+    return true;
+  }
+  return false;
+}
+
+// src/commands/Add.jsx
+import { jsx as jsx3, jsxs as jsxs4 } from "react/jsx-runtime";
+var STEPS = {
+  TARGET: "target",
+  COLLECTIONS: "collections",
+  TYPE: "type",
+  ITEMS: "items",
+  INSTALLING: "installing",
+  DONE: "done"
+};
+function Add({ directSkills }) {
+  const { exit } = useApp();
+  const [step, setStep] = useState3(STEPS.TARGET);
+  const [targetKey, setTargetKey] = useState3(null);
+  const [selectedCollection, setSelectedCollection] = useState3(null);
+  const [selectedType, setSelectedType] = useState3(null);
+  const [toInstall, setToInstall] = useState3({ skills: [], agents: [] });
+  const [results, setResults] = useState3({ skills: 0, agents: 0, deps: [] });
+  const destRoot = process.cwd();
+  useEffect(() => {
+    if (directSkills && directSkills.length > 0 && targetKey) {
+      installByName(directSkills, targets[targetKey], destRoot).then((res) => {
+        setResults(res);
+        setStep(STEPS.DONE);
+      });
+    }
+  }, [targetKey]);
+  async function installByName(names, targetConfig, dest) {
+    const collections = listCollections();
+    let skillCount = 0;
+    let agentCount = 0;
+    for (const name of names) {
+      for (const col of collections) {
+        const { skills, agents } = scanCollection(col);
+        if (skills.includes(name)) {
+          if (await installSkill(col, name, targetConfig, dest)) skillCount++;
+          break;
+        }
+        if (agents.includes(name)) {
+          if (await installAgent(col, name, targetConfig, dest)) agentCount++;
+          break;
+        }
+      }
+    }
+    return { skills: skillCount, agents: agentCount, deps: [] };
+  }
+  function getAvailableTypes(col) {
+    const { skills, agents } = scanCollection(col);
+    const types = [];
+    if (skills.length > 0) types.push({ label: `Skills (${skills.length})`, value: "skills" });
+    if (agents.length > 0) types.push({ label: `Agents (${agents.length})`, value: "agents" });
+    return types;
+  }
+  function handleTargetSelect(key) {
+    setTargetKey(key);
+    if (directSkills && directSkills.length > 0) return;
+    setStep(STEPS.COLLECTIONS);
+  }
+  function handleCollectionSelect(col) {
+    setSelectedCollection(col);
+    setToInstall({ skills: [], agents: [] });
+    const types = getAvailableTypes(col);
+    if (types.length === 1) {
+      setSelectedType(types[0].value);
+      setStep(STEPS.ITEMS);
+    } else if (types.length === 0) {
+      setStep(STEPS.DONE);
+    } else {
+      setStep(STEPS.TYPE);
+    }
+  }
+  function handleTypeSelect(type) {
+    setSelectedType(type);
+    setStep(STEPS.ITEMS);
+  }
+  function handleItemsSelect(names) {
+    const col = selectedCollection;
+    if (selectedType === "skills") {
+      const newSkills = names.map((name) => ({ collection: col, name }));
+      setToInstall((prev) => ({ ...prev, skills: [...prev.skills, ...newSkills] }));
+    } else {
+      const newAgents = names.map((name) => ({ collection: col, name }));
+      setToInstall((prev) => ({ ...prev, agents: [...prev.agents, ...newAgents] }));
+    }
+    setStep(STEPS.INSTALLING);
+  }
+  function handleTargetBack() {
+    exit();
+  }
+  function handleCollectionsBack() {
+    setTargetKey(null);
+    setStep(STEPS.TARGET);
+  }
+  function handleTypeBack() {
+    setSelectedCollection(null);
+    setStep(STEPS.COLLECTIONS);
+  }
+  function handleItemsBack() {
+    const types = getAvailableTypes(selectedCollection);
+    if (types.length > 1) {
+      setSelectedType(null);
+      setStep(STEPS.TYPE);
+    } else {
+      setSelectedCollection(null);
+      setStep(STEPS.COLLECTIONS);
+    }
+  }
+  useEffect(() => {
+    if (step !== STEPS.INSTALLING) return;
+    async function doInstall() {
+      const targetConfig = targets[targetKey];
+      const deps = resolveDependencies(toInstall, [selectedCollection]);
+      const allSkills = [...toInstall.skills, ...deps.skills];
+      const allAgents = [...toInstall.agents, ...deps.agents];
+      let skillCount = 0;
+      let agentCount = 0;
+      for (const { collection, name } of allSkills) {
+        if (await installSkill(collection, name, targetConfig, destRoot)) skillCount++;
+      }
+      for (const { collection, name } of allAgents) {
+        if (await installAgent(collection, name, targetConfig, destRoot)) agentCount++;
+      }
+      setResults({
+        skills: skillCount,
+        agents: agentCount,
+        deps: [...deps.skills, ...deps.agents]
+      });
+      setStep(STEPS.DONE);
+    }
+    doInstall();
+  }, [step]);
+  if (step === STEPS.TARGET) {
+    return /* @__PURE__ */ jsx3(
+      Select,
+      {
+        items: targetList,
+        onSelect: handleTargetSelect,
+        onBack: handleTargetBack,
+        message: "Where to install? (target LLM/IDE)"
+      }
+    );
+  }
+  if (step === STEPS.COLLECTIONS) {
+    const collections = listCollections();
+    const items = collections.map((c) => ({ label: c, value: c }));
+    return /* @__PURE__ */ jsx3(
+      Select,
+      {
+        items,
+        onSelect: handleCollectionSelect,
+        onBack: handleCollectionsBack,
+        message: "Select collection:"
+      }
+    );
+  }
+  if (step === STEPS.TYPE) {
+    const types = getAvailableTypes(selectedCollection);
+    return /* @__PURE__ */ jsx3(
+      Select,
+      {
+        items: types,
+        onSelect: handleTypeSelect,
+        onBack: handleTypeBack,
+        message: `What to install from "${selectedCollection}"?`
+      }
+    );
+  }
+  if (step === STEPS.ITEMS) {
+    const col = selectedCollection;
+    const { skills, agents } = scanCollection(col);
+    if (selectedType === "skills") {
+      const items = skills.map((s) => {
+        const meta = getSkillMeta(col, s);
+        return { label: s, value: s, description: meta.description, checked: false };
+      });
+      return /* @__PURE__ */ jsx3(
+        MultiSelect,
+        {
+          items,
+          onSubmit: handleItemsSelect,
+          onBack: handleItemsBack,
+          message: `Select skills from "${col}":`
+        }
+      );
+    }
+    if (selectedType === "agents") {
+      const items = agents.map((a) => {
+        const meta = getAgentMeta(col, a);
+        return { label: a, value: a, description: meta.description, checked: false };
+      });
+      return /* @__PURE__ */ jsx3(
+        MultiSelect,
+        {
+          items,
+          onSubmit: handleItemsSelect,
+          onBack: handleItemsBack,
+          message: `Select agents from "${col}":`
+        }
+      );
+    }
+  }
+  if (step === STEPS.INSTALLING) {
+    return /* @__PURE__ */ jsx3(Text4, { color: "yellow", children: "Installing..." });
+  }
+  if (step === STEPS.DONE) {
+    setTimeout(() => exit(), 100);
+    return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", marginTop: 1, children: [
+      results.deps.length > 0 && /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsx3(Info, { children: "Auto-installed dependencies:" }),
+        results.deps.map((d) => /* @__PURE__ */ jsxs4(Text4, { color: "cyan", children: [
+          "  + ",
+          d.name,
+          " (from ",
+          d.collection,
+          ")"
+        ] }, d.name))
+      ] }),
+      /* @__PURE__ */ jsxs4(Success, { children: [
+        "Installed ",
+        results.skills,
+        " skill(s), ",
+        results.agents,
+        " agent(s)",
+        targetKey && ` to ${targets[targetKey].skillsDir}/`
+      ] })
+    ] });
+  }
+  return null;
+}
+
+// src/commands/List.jsx
+import React5 from "react";
+import { Box as Box4, Text as Text5, useApp as useApp2 } from "ink";
+import { jsx as jsx4, jsxs as jsxs5 } from "react/jsx-runtime";
+function List() {
+  const { exit } = useApp2();
+  const collections = listCollections();
+  setTimeout(() => exit(), 100);
+  if (collections.length === 0) {
+    return /* @__PURE__ */ jsx4(Text5, { color: "yellow", children: "No collections found." });
+  }
+  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "cyan", children: [
+      "\n",
+      "Available skills & agents",
+      "\n"
+    ] }),
+    collections.map((col) => {
+      const { skills, agents } = scanCollection(col);
+      if (skills.length === 0 && agents.length === 0) return null;
+      return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "yellow", children: [
+          "  ",
+          "\u{1F4E6} ",
+          col
+        ] }),
+        skills.length > 0 && /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: [
+          /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "magenta", children: [
+            "  ",
+            "Skills"
+          ] }),
+          skills.map((s) => {
+            const meta = getSkillMeta(col, s);
+            return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginBottom: 1, marginLeft: 2, children: [
+              /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "green", children: [
+                "  ",
+                s
+              ] }),
+              meta.description && /* @__PURE__ */ jsxs5(Text5, { color: "gray", children: [
+                "      ",
+                meta.description
+              ] })
+            ] }, s);
+          })
+        ] }),
+        agents.length > 0 && /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: [
+          /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "magenta", children: [
+            "  ",
+            "Agents"
+          ] }),
+          agents.map((a) => {
+            const meta = getAgentMeta(col, a);
+            return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginBottom: 1, marginLeft: 2, children: [
+              /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "blue", children: [
+                "  ",
+                a
+              ] }),
+              meta.description && /* @__PURE__ */ jsxs5(Text5, { color: "gray", children: [
+                "      ",
+                meta.description
+              ] })
+            ] }, a);
+          })
+        ] })
+      ] }, col);
+    })
+  ] });
+}
+
+// src/commands/Update.jsx
+import React8, { useState as useState4, useEffect as useEffect2 } from "react";
+import { Box as Box7, Text as Text8, useApp as useApp3 } from "ink";
+import path3 from "path";
+import fs3 from "fs-extra";
+
+// src/components/Confirm.jsx
+import React6 from "react";
+import { Box as Box5, Text as Text6, useInput as useInput3 } from "ink";
+import { jsx as jsx5, jsxs as jsxs6 } from "react/jsx-runtime";
+function Confirm({ message, onConfirm, onBack }) {
+  useInput3((input, key) => {
+    if (input === "y" || input === "Y") {
+      onConfirm(true);
+    }
+    if (input === "n" || input === "N") {
+      onConfirm(false);
+    }
+    if (key.escape && onBack) {
+      onBack();
+    }
+  });
+  return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsxs6(Text6, { bold: true, color: "cyan", children: [
+    "? ",
+    message,
+    /* @__PURE__ */ jsxs6(Text6, { color: "gray", children: [
+      " (y/n",
+      onBack ? ", esc back" : "",
+      ")"
+    ] })
+  ] }) });
+}
+
+// src/components/DiffView.jsx
+import React7 from "react";
+import { Box as Box6, Text as Text7 } from "ink";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function DiffView({ patch }) {
+  const lines = patch.split("\n");
+  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", marginLeft: 2, children: lines.map((line, idx) => {
+    let color = void 0;
+    if (line.startsWith("+") && !line.startsWith("+++")) color = "green";
+    else if (line.startsWith("-") && !line.startsWith("---")) color = "red";
+    else if (line.startsWith("@@")) color = "cyan";
+    return /* @__PURE__ */ jsx6(Text7, { color, children: line }, idx);
+  }) });
+}
+
+// src/utils/diffUtil.js
+import { createTwoFilesPatch } from "diff";
+function computeDiff(filePath, localContent, latestContent) {
+  return createTwoFilesPatch(
+    `local/${filePath}`,
+    `latest/${filePath}`,
+    localContent,
+    latestContent,
+    "",
+    ""
+  );
+}
+function hasChanges(localContent, latestContent) {
+  return localContent.trim() !== latestContent.trim();
+}
+
+// src/commands/Update.jsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var STEPS2 = {
+  TARGET: "target",
+  CHECKING: "checking",
+  CONFIRM: "confirm",
+  DONE: "done"
+};
+function Update() {
+  const { exit } = useApp3();
+  const [step, setStep] = useState4(STEPS2.TARGET);
+  const [targetKey, setTargetKey] = useState4(null);
+  const [changedItems, setChangedItems] = useState4([]);
+  const [currentIdx, setCurrentIdx] = useState4(0);
+  const [updatedCount, setUpdatedCount] = useState4(0);
+  const [skippedCount, setSkippedCount] = useState4(0);
+  const destRoot = process.cwd();
+  function findSource(name, type) {
+    for (const col of listCollections()) {
+      const { skills, agents } = scanCollection(col);
+      if (type === "skill" && skills.includes(name)) return { collection: col };
+      if (type === "agent" && agents.includes(name)) return { collection: col };
+    }
+    return null;
+  }
+  useEffect2(() => {
+    if (step !== STEPS2.CHECKING) return;
+    const targetConfig = targets[targetKey];
+    const installed = listInstalled(targetConfig, destRoot);
+    const changed = [];
+    for (const skillName of installed.skills) {
+      const source = findSource(skillName, "skill");
+      if (!source) continue;
+      const localFile = path3.join(destRoot, targetConfig.skillsDir, skillName, "SKILL.md");
+      const latestFile = path3.join(getCollectionsDir(), source.collection, "skills", skillName, "SKILL.md");
+      if (!fs3.existsSync(localFile) || !fs3.existsSync(latestFile)) continue;
+      const localContent = fs3.readFileSync(localFile, "utf-8");
+      const latestContent = fs3.readFileSync(latestFile, "utf-8");
+      if (hasChanges(localContent, latestContent)) {
+        changed.push({
+          name: skillName,
+          type: "skill",
+          collection: source.collection,
+          patch: computeDiff("SKILL.md", localContent, latestContent)
+        });
+      }
+    }
+    for (const agentName of installed.agents) {
+      const source = findSource(agentName, "agent");
+      if (!source) continue;
+      const localFile = path3.join(destRoot, targetConfig.agentsDir, `${agentName}.md`);
+      const latestFile = path3.join(getCollectionsDir(), source.collection, "agents", `${agentName}.md`);
+      if (!fs3.existsSync(localFile) || !fs3.existsSync(latestFile)) continue;
+      const localContent = fs3.readFileSync(localFile, "utf-8");
+      const latestContent = fs3.readFileSync(latestFile, "utf-8");
+      if (hasChanges(localContent, latestContent)) {
+        changed.push({
+          name: agentName,
+          type: "agent",
+          collection: source.collection,
+          patch: computeDiff(`${agentName}.md`, localContent, latestContent)
+        });
+      }
+    }
+    setChangedItems(changed);
+    if (changed.length === 0) {
+      setStep(STEPS2.DONE);
+    } else {
+      setCurrentIdx(0);
+      setStep(STEPS2.CONFIRM);
+    }
+  }, [step]);
+  function handleTargetSelect(key) {
+    setTargetKey(key);
+    setStep(STEPS2.CHECKING);
+  }
+  function handleConfirm(yes) {
+    const item = changedItems[currentIdx];
+    const targetConfig = targets[targetKey];
+    if (yes) {
+      if (item.type === "skill") {
+        const src = path3.join(getCollectionsDir(), item.collection, "skills", item.name);
+        const dest = path3.join(destRoot, targetConfig.skillsDir, item.name);
+        fs3.copySync(src, dest, { overwrite: true });
+      } else {
+        const src = path3.join(getCollectionsDir(), item.collection, "agents", `${item.name}.md`);
+        const dest = path3.join(destRoot, targetConfig.agentsDir, `${item.name}.md`);
+        fs3.copySync(src, dest, { overwrite: true });
+      }
+      setUpdatedCount((c) => c + 1);
+    } else {
+      setSkippedCount((c) => c + 1);
+    }
+    if (currentIdx + 1 < changedItems.length) {
+      setCurrentIdx((i) => i + 1);
+    } else {
+      setStep(STEPS2.DONE);
+    }
+  }
+  if (step === STEPS2.TARGET) {
+    return /* @__PURE__ */ jsx7(Select, { items: targetList, onSelect: handleTargetSelect, onBack: () => exit(), message: "Which target to update?" });
+  }
+  if (step === STEPS2.CHECKING) {
+    return /* @__PURE__ */ jsx7(Text8, { color: "yellow", children: "Checking for updates..." });
+  }
+  if (step === STEPS2.CONFIRM) {
+    const item = changedItems[currentIdx];
+    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Warning, { children: [
+        item.name,
+        ": local differs from latest"
+      ] }),
+      /* @__PURE__ */ jsx7(DiffView, { patch: item.patch }),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Confirm, { message: `Update ${item.name}?`, onConfirm: handleConfirm }) })
+    ] });
+  }
+  if (step === STEPS2.DONE) {
+    setTimeout(() => exit(), 100);
+    if (changedItems.length === 0) {
+      return /* @__PURE__ */ jsx7(Success, { children: "All installed skills are up to date." });
+    }
+    return /* @__PURE__ */ jsxs7(Success, { children: [
+      updatedCount,
+      " updated, ",
+      skippedCount,
+      " skipped"
+    ] });
+  }
+  return null;
+}
+
+// src/commands/Remove.jsx
+import React9, { useState as useState5 } from "react";
+import { Box as Box8, Text as Text9, useApp as useApp4 } from "ink";
+import path4 from "path";
+import fs4 from "fs-extra";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var STEPS3 = {
+  TARGET: "target",
+  CONFIRM: "confirm",
+  DONE: "done"
+};
+function Remove({ skillNames }) {
+  const { exit } = useApp4();
+  const [step, setStep] = useState5(STEPS3.TARGET);
+  const [targetKey, setTargetKey] = useState5(null);
+  const [currentIdx, setCurrentIdx] = useState5(0);
+  const [removedCount, setRemovedCount] = useState5(0);
+  const [notFound, setNotFound] = useState5([]);
+  const destRoot = process.cwd();
+  function handleTargetSelect(key) {
+    setTargetKey(key);
+    const targetConfig = targets[key];
+    const missing = [];
+    for (const name of skillNames) {
+      const skillPath = path4.join(destRoot, targetConfig.skillsDir, name);
+      const agentPath = path4.join(destRoot, targetConfig.agentsDir, `${name}.md`);
+      if (!fs4.existsSync(skillPath) && !fs4.existsSync(agentPath)) {
+        missing.push(name);
+      }
+    }
+    setNotFound(missing);
+    const existing = skillNames.filter((n) => !missing.includes(n));
+    if (existing.length === 0) {
+      setStep(STEPS3.DONE);
+    } else {
+      setStep(STEPS3.CONFIRM);
+    }
+  }
+  async function handleConfirm(yes) {
+    if (yes) {
+      const name = getExisting()[currentIdx];
+      const targetConfig = targets[targetKey];
+      const skillRemoved = await removeSkill(name, targetConfig, destRoot);
+      const agentRemoved = !skillRemoved ? await removeAgent(name, targetConfig, destRoot) : false;
+      if (skillRemoved || agentRemoved) {
+        setRemovedCount((c) => c + 1);
+      }
+    }
+    if (currentIdx + 1 < getExisting().length) {
+      setCurrentIdx((i) => i + 1);
+    } else {
+      setStep(STEPS3.DONE);
+    }
+  }
+  function getExisting() {
+    return skillNames.filter((n) => !notFound.includes(n));
+  }
+  if (step === STEPS3.TARGET) {
+    return /* @__PURE__ */ jsx8(
+      Select,
+      {
+        items: targetList,
+        onSelect: handleTargetSelect,
+        onBack: () => exit(),
+        message: "Which target to remove from?"
+      }
+    );
+  }
+  if (step === STEPS3.CONFIRM) {
+    const name = getExisting()[currentIdx];
+    return /* @__PURE__ */ jsx8(Confirm, { message: `Remove "${name}"?`, onConfirm: handleConfirm });
+  }
+  if (step === STEPS3.DONE) {
+    setTimeout(() => exit(), 100);
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      notFound.map((n) => /* @__PURE__ */ jsxs8(ErrorMsg, { children: [
+        "Not found: ",
+        n
+      ] }, n)),
+      /* @__PURE__ */ jsxs8(Success, { children: [
+        removedCount,
+        " removed"
+      ] })
+    ] });
+  }
+  return null;
+}
+
+// src/cli.jsx
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+var args = process.argv.slice(2);
+var command = args[0];
+var restArgs = args.slice(1);
+function Help() {
+  const commands = [
+    { name: "add [skills...]", desc: "Install skills/agents (interactive if no args)" },
+    { name: "list", desc: "List all available skills and agents" },
+    { name: "update", desc: "Update installed skills to latest version" },
+    { name: "remove <skills>", desc: "Remove installed skills/agents" },
+    { name: "help", desc: "Show this help message" }
+  ];
+  const examples = [
+    "npx @hiver/skills add",
+    "npx @hiver/skills add discuss-problem create-prd",
+    "npx @hiver/skills list",
+    "npx @hiver/skills update",
+    "npx @hiver/skills remove discuss-problem"
+  ];
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs9(Box9, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx9(Text10, { bold: true, color: "cyan", children: "@hiver/skills" }),
+      /* @__PURE__ */ jsx9(Text10, { color: "gray", children: " \u2014 Shared Claude Code skills & agents" })
+    ] }),
+    /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx9(Text10, { bold: true, color: "yellow", children: "Commands" }),
+      commands.map((cmd) => /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs9(Text10, { bold: true, color: "green", children: [
+          "  ",
+          cmd.name
+        ] }),
+        /* @__PURE__ */ jsxs9(Text10, { color: "gray", children: [
+          "      ",
+          cmd.desc
+        ] })
+      ] }, cmd.name))
+    ] }),
+    /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Text10, { bold: true, color: "yellow", children: "Examples" }),
+      examples.map((ex, i) => /* @__PURE__ */ jsxs9(Text10, { color: "white", children: [
+        "    $ ",
+        ex
+      ] }, i))
+    ] })
+  ] });
+}
+function App() {
+  switch (command) {
+    case "add":
+      return /* @__PURE__ */ jsx9(Add, { directSkills: restArgs.length > 0 ? restArgs : null });
+    case "list":
+      return /* @__PURE__ */ jsx9(List, {});
+    case "update":
+      return /* @__PURE__ */ jsx9(Update, {});
+    case "remove":
+      if (restArgs.length === 0) {
+        return /* @__PURE__ */ jsxs9(Text10, { color: "red", children: [
+          "Usage: hiver-skills remove ",
+          "<skill1> [skill2] ..."
+        ] });
+      }
+      return /* @__PURE__ */ jsx9(Remove, { skillNames: restArgs });
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      return /* @__PURE__ */ jsx9(Help, {});
+    default:
+      return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs9(Text10, { color: "red", children: [
+          "Unknown command: ",
+          command
+        ] }),
+        /* @__PURE__ */ jsxs9(Text10, { color: "gray", children: [
+          "Run ",
+          /* @__PURE__ */ jsx9(Text10, { color: "green", children: "hiver-skills help" }),
+          " for usage."
+        ] })
+      ] });
+  }
+}
+render(/* @__PURE__ */ jsx9(App, {}));