@hiver/skills 1.0.3 → 1.0.5

package/dist/cli.js

@@ -239,6 +239,15 @@ function getAgentMeta(collectionName, agentName) {
     dependencies: Array.isArray(fm.dependencies) ? fm.dependencies : []
   };
 }
+function findCollectionsContaining(name, type) {
+  const matches = [];
+  for (const col of listCollections()) {
+    const { skills, agents } = scanCollection(col);
+    if (type === "skill" && skills.includes(name)) matches.push(col);
+    if (type === "agent" && agents.includes(name)) matches.push(col);
+  }
+  return matches;
+}
 function resolveDependencies(selected, selectedCollections) {
   const installedNames = /* @__PURE__ */ new Set([
     ...selected.skills.map((s) => s.name),
@@ -341,34 +350,8 @@ function Add({ directSkills }) {
   const [selectedType, setSelectedType] = useState3(null);
   const [toInstall, setToInstall] = useState3({ skills: [], agents: [] });
   const [results, setResults] = useState3({ skills: 0, agents: 0, deps: [] });
+  const [directMissing, setDirectMissing] = useState3([]);
   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 = [];
@@ -378,11 +361,29 @@ function Add({ directSkills }) {
   }
   function handleTargetSelect(key) {
     setTargetKey(key);
-    if (directSkills && directSkills.length > 0) return;
     setStep(STEPS.COLLECTIONS);
   }
   function handleCollectionSelect(col) {
     setSelectedCollection(col);
+    if (directSkills && directSkills.length > 0) {
+      const { skills, agents } = scanCollection(col);
+      const skillItems = [];
+      const agentItems = [];
+      const missing = [];
+      for (const name of directSkills) {
+        if (skills.includes(name)) skillItems.push({ collection: col, name });
+        else if (agents.includes(name)) agentItems.push({ collection: col, name });
+        else missing.push(`${name} (not in ${col})`);
+      }
+      setDirectMissing(missing);
+      setToInstall({ skills: skillItems, agents: agentItems });
+      if (skillItems.length === 0 && agentItems.length === 0) {
+        setStep(STEPS.DONE);
+      } else {
+        setStep(STEPS.INSTALLING);
+      }
+      return;
+    }
     setToInstall({ skills: [], agents: [] });
     const types = getAvailableTypes(col);
     if (types.length === 1) {
@@ -466,8 +467,24 @@ function Add({ directSkills }) {
     );
   }
   if (step === STEPS.COLLECTIONS) {
-    const collections = listCollections();
+    let collections = listCollections();
+    if (directSkills && directSkills.length > 0) {
+      const union = /* @__PURE__ */ new Set();
+      for (const name of directSkills) {
+        for (const c of findCollectionsContaining(name, "skill")) union.add(c);
+        for (const c of findCollectionsContaining(name, "agent")) union.add(c);
+      }
+      collections = collections.filter((c) => union.has(c));
+    }
     const items = collections.map((c) => ({ label: c, value: c }));
+    if (items.length === 0) {
+      setTimeout(() => exit(), 100);
+      return /* @__PURE__ */ jsxs4(ErrorMsg, { children: [
+        "None of: ",
+        directSkills.join(", "),
+        " found in any collection."
+      ] });
+    }
     return /* @__PURE__ */ jsx3(
       Select,
       {
@@ -530,6 +547,10 @@ function Add({ directSkills }) {
   if (step === STEPS.DONE) {
     setTimeout(() => exit(), 100);
     return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", marginTop: 1, children: [
+      directMissing.length > 0 && /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsxs4(ErrorMsg, { children: [
+        "Not found in any collection: ",
+        directMissing.join(", ")
+      ] }) }),
       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: [
@@ -625,8 +646,8 @@ function List() {
 // 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";
+import path4 from "path";
+import fs4 from "fs-extra";
 
 // src/components/Confirm.jsx
 import React6 from "react";
@@ -671,6 +692,8 @@ function DiffView({ patch }) {
 }
 
 // src/utils/diffUtil.js
+import path3 from "path";
+import fs3 from "fs-extra";
 import { createTwoFilesPatch } from "diff";
 function computeDiff(filePath, localContent, latestContent) {
   return createTwoFilesPatch(
@@ -685,133 +708,367 @@ function computeDiff(filePath, localContent, latestContent) {
 function hasChanges(localContent, latestContent) {
   return localContent.trim() !== latestContent.trim();
 }
+function walkFiles(dir) {
+  const out = [];
+  if (!fs3.existsSync(dir)) return out;
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      for (const sub of walkFiles(full)) out.push(path3.join(entry.name, sub));
+    } else if (entry.isFile()) {
+      out.push(entry.name);
+    }
+  }
+  return out;
+}
+function isBinary(buf) {
+  const sample = buf.subarray(0, Math.min(buf.length, 8e3));
+  for (let i = 0; i < sample.length; i++) {
+    if (sample[i] === 0) return true;
+  }
+  return false;
+}
+function hasDirChanges(localDir, latestDir) {
+  const localFiles = new Set(walkFiles(localDir));
+  const latestFiles = new Set(walkFiles(latestDir));
+  if (localFiles.size !== latestFiles.size) return true;
+  for (const rel of latestFiles) {
+    if (!localFiles.has(rel)) return true;
+    const a = fs3.readFileSync(path3.join(localDir, rel));
+    const b = fs3.readFileSync(path3.join(latestDir, rel));
+    if (!a.equals(b)) return true;
+  }
+  for (const rel of localFiles) {
+    if (!latestFiles.has(rel)) return true;
+  }
+  return false;
+}
+function computeDirDiff(localDir, latestDir) {
+  const localFiles = new Set(walkFiles(localDir));
+  const latestFiles = new Set(walkFiles(latestDir));
+  const allFiles = /* @__PURE__ */ new Set([...localFiles, ...latestFiles]);
+  const parts = [];
+  for (const rel of [...allFiles].sort()) {
+    const localBuf = localFiles.has(rel) ? fs3.readFileSync(path3.join(localDir, rel)) : Buffer.alloc(0);
+    const latestBuf = latestFiles.has(rel) ? fs3.readFileSync(path3.join(latestDir, rel)) : Buffer.alloc(0);
+    if (localBuf.equals(latestBuf)) continue;
+    if (isBinary(localBuf) || isBinary(latestBuf)) {
+      const verb = !localFiles.has(rel) ? "added" : !latestFiles.has(rel) ? "removed" : "changed";
+      parts.push(`Binary file ${rel} ${verb} (${localBuf.length} \u2192 ${latestBuf.length} bytes)`);
+      continue;
+    }
+    const localContent = localBuf.toString("utf-8");
+    const latestContent = latestBuf.toString("utf-8");
+    if (localContent.trim() === latestContent.trim()) continue;
+    parts.push(computeDiff(rel, localContent, latestContent));
+  }
+  return parts.join("\n");
+}
 
 // src/commands/Update.jsx
 import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
 var STEPS2 = {
   TARGET: "target",
-  CHECKING: "checking",
+  COLLECTION: "collection",
+  ITEMS: "items",
+  RESOLVE: "resolve",
   CONFIRM: "confirm",
   DONE: "done"
 };
-function Update() {
+function detectType(name, targetConfig, destRoot) {
+  const skillPath = path4.join(destRoot, targetConfig.skillsDir, name, "SKILL.md");
+  if (fs4.existsSync(skillPath)) return "skill";
+  const agentPath = path4.join(destRoot, targetConfig.agentsDir, `${name}.md`);
+  if (fs4.existsSync(agentPath)) return "agent";
+  return null;
+}
+function Update({ directSkills }) {
   const { exit } = useApp3();
   const [step, setStep] = useState4(STEPS2.TARGET);
   const [targetKey, setTargetKey] = useState4(null);
-  const [changedItems, setChangedItems] = useState4([]);
+  const [selectedCollection, setSelectedCollection] = useState4(null);
+  const [queue, setQueue] = useState4([]);
   const [currentIdx, setCurrentIdx] = useState4(0);
+  const [currentPatch, setCurrentPatch] = useState4(null);
   const [updatedCount, setUpdatedCount] = useState4(0);
   const [skippedCount, setSkippedCount] = useState4(0);
+  const [installedCount, setInstalledCount] = useState4(0);
+  const [missingNames, setMissingNames] = useState4([]);
+  const [directInfo, setDirectInfo] = useState4([]);
+  const [skipReasons, setSkipReasons] = useState4([]);
   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 };
+  function handleTargetSelect(key) {
+    setTargetKey(key);
+    if (directSkills && directSkills.length > 0) {
+      const targetConfig = targets[key];
+      const info = [];
+      const missing = [];
+      for (const name of directSkills) {
+        let type = detectType(name, targetConfig, destRoot);
+        let installed = type !== null;
+        if (!type) {
+          if (findCollectionsContaining(name, "skill").length > 0) type = "skill";
+          else if (findCollectionsContaining(name, "agent").length > 0) type = "agent";
+        }
+        if (!type) {
+          missing.push(name);
+          continue;
+        }
+        const cols = findCollectionsContaining(name, type);
+        if (cols.length === 0) {
+          missing.push(name);
+          continue;
+        }
+        info.push({ name, type, installed, collections: cols });
+      }
+      setMissingNames(missing);
+      setDirectInfo(info);
+      if (info.length === 0) {
+        setStep(STEPS2.DONE);
+        return;
+      }
     }
-    return null;
+    setStep(STEPS2.COLLECTION);
   }
-  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)
-        });
+  function handleCollectionSelect(collection) {
+    setSelectedCollection(collection);
+    if (directSkills && directSkills.length > 0) {
+      const items = [];
+      const skipped = [];
+      for (const entry of directInfo) {
+        if (entry.collections.includes(collection)) {
+          items.push({ name: entry.name, type: entry.type, installed: entry.installed });
+        } else {
+          skipped.push(`${entry.name} (not in ${collection})`);
+        }
       }
-    }
-    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)
-        });
+      if (skipped.length > 0) {
+        setMissingNames((prev) => [...prev, ...skipped]);
+      }
+      setQueue(items);
+      setCurrentIdx(0);
+      if (items.length === 0) {
+        setStep(STEPS2.DONE);
+      } else {
+        setStep(STEPS2.RESOLVE);
       }
+    } else {
+      setStep(STEPS2.ITEMS);
     }
-    setChangedItems(changed);
-    if (changed.length === 0) {
+  }
+  function handleItemsSubmit(values) {
+    const items = values.map((v) => {
+      const [type, name] = v.split(":");
+      return { name, type, installed: true };
+    });
+    setQueue(items);
+    setCurrentIdx(0);
+    if (items.length === 0) {
       setStep(STEPS2.DONE);
     } else {
-      setCurrentIdx(0);
+      setStep(STEPS2.RESOLVE);
+    }
+  }
+  useEffect2(() => {
+    if (step !== STEPS2.RESOLVE) return;
+    const item = queue[currentIdx];
+    if (!item) {
+      setStep(STEPS2.DONE);
+      return;
+    }
+    processItem(item);
+  }, [step, currentIdx]);
+  async function processItem(item) {
+    const targetConfig = targets[targetKey];
+    const collection = selectedCollection;
+    if (!item.installed) {
+      if (item.type === "skill") {
+        await installSkill(collection, item.name, targetConfig, destRoot);
+      } else {
+        await installAgent(collection, item.name, targetConfig, destRoot);
+      }
+      setInstalledCount((c) => c + 1);
+      advance();
+      return;
+    }
+    if (item.type === "skill") {
+      const localDir = path4.join(destRoot, targetConfig.skillsDir, item.name);
+      const latestDir = path4.join(getCollectionsDir(), collection, "skills", item.name);
+      if (!fs4.existsSync(localDir) || !fs4.existsSync(latestDir)) {
+        recordSkip(item.name, "source or local directory missing");
+        advance();
+        return;
+      }
+      if (!hasDirChanges(localDir, latestDir)) {
+        recordSkip(item.name, `already up-to-date with ${collection}`);
+        advance();
+        return;
+      }
+      setCurrentPatch(computeDirDiff(localDir, latestDir));
       setStep(STEPS2.CONFIRM);
+      return;
     }
-  }, [step]);
-  function handleTargetSelect(key) {
-    setTargetKey(key);
-    setStep(STEPS2.CHECKING);
+    const localFile = path4.join(destRoot, targetConfig.agentsDir, `${item.name}.md`);
+    const latestFile = path4.join(getCollectionsDir(), collection, "agents", `${item.name}.md`);
+    if (!fs4.existsSync(localFile) || !fs4.existsSync(latestFile)) {
+      recordSkip(item.name, "source or local file missing");
+      advance();
+      return;
+    }
+    const localContent = fs4.readFileSync(localFile, "utf-8");
+    const latestContent = fs4.readFileSync(latestFile, "utf-8");
+    if (!hasChanges(localContent, latestContent)) {
+      recordSkip(item.name, `already up-to-date with ${collection}`);
+      advance();
+      return;
+    }
+    setCurrentPatch(computeDiff(`${item.name}.md`, localContent, latestContent));
+    setStep(STEPS2.CONFIRM);
+  }
+  function recordSkip(name, reason) {
+    setSkippedCount((c) => c + 1);
+    setSkipReasons((prev) => [...prev, { name, reason }]);
   }
   function handleConfirm(yes) {
-    const item = changedItems[currentIdx];
+    const item = queue[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 });
+        const src = path4.join(getCollectionsDir(), selectedCollection, "skills", item.name);
+        const dest = path4.join(destRoot, targetConfig.skillsDir, item.name);
+        fs4.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 });
+        const src = path4.join(getCollectionsDir(), selectedCollection, "agents", `${item.name}.md`);
+        const dest = path4.join(destRoot, targetConfig.agentsDir, `${item.name}.md`);
+        fs4.copySync(src, dest, { overwrite: true });
       }
       setUpdatedCount((c) => c + 1);
     } else {
-      setSkippedCount((c) => c + 1);
+      recordSkip(item.name, "declined");
     }
-    if (currentIdx + 1 < changedItems.length) {
+    advance();
+  }
+  function advance() {
+    setCurrentPatch(null);
+    if (currentIdx + 1 < queue.length) {
       setCurrentIdx((i) => i + 1);
+      setStep(STEPS2.RESOLVE);
     } else {
       setStep(STEPS2.DONE);
     }
   }
   if (step === STEPS2.TARGET) {
-    return /* @__PURE__ */ jsx7(Select, { items: targetList, onSelect: handleTargetSelect, onBack: () => exit(), message: "Which target to update?" });
+    return /* @__PURE__ */ jsx7(
+      Select,
+      {
+        items: targetList,
+        onSelect: handleTargetSelect,
+        onBack: () => exit(),
+        message: "Which target to update?"
+      }
+    );
+  }
+  if (step === STEPS2.COLLECTION) {
+    let collectionNames;
+    if (directSkills && directSkills.length > 0) {
+      const union = /* @__PURE__ */ new Set();
+      for (const entry of directInfo) {
+        for (const c of entry.collections) union.add(c);
+      }
+      collectionNames = listCollections().filter((c) => union.has(c));
+    } else {
+      collectionNames = listCollections();
+    }
+    const items = collectionNames.map((c) => ({ label: c, value: c }));
+    return /* @__PURE__ */ jsx7(
+      Select,
+      {
+        items,
+        onSelect: handleCollectionSelect,
+        onBack: () => setStep(STEPS2.TARGET),
+        message: "Pick collection to update from:"
+      }
+    );
+  }
+  if (step === STEPS2.ITEMS) {
+    const targetConfig = targets[targetKey];
+    const installed = listInstalled(targetConfig, destRoot);
+    const { skills, agents } = scanCollection(selectedCollection);
+    const items = [
+      ...installed.skills.filter((name) => skills.includes(name)).map((name) => ({
+        label: `${name} (skill)`,
+        value: `skill:${name}`,
+        checked: false
+      })),
+      ...installed.agents.filter((name) => agents.includes(name)).map((name) => ({
+        label: `${name} (agent)`,
+        value: `agent:${name}`,
+        checked: false
+      }))
+    ];
+    if (items.length === 0) {
+      setTimeout(() => exit(), 100);
+      return /* @__PURE__ */ jsxs7(Info, { children: [
+        'No installed skills/agents from "',
+        selectedCollection,
+        '" under ',
+        targetConfig.skillsDir,
+        "/."
+      ] });
+    }
+    return /* @__PURE__ */ jsx7(
+      MultiSelect,
+      {
+        items,
+        onSubmit: handleItemsSubmit,
+        onBack: () => setStep(STEPS2.COLLECTION),
+        message: `Select skills/agents from "${selectedCollection}" to update:`
+      }
+    );
   }
-  if (step === STEPS2.CHECKING) {
-    return /* @__PURE__ */ jsx7(Text8, { color: "yellow", children: "Checking for updates..." });
+  if (step === STEPS2.RESOLVE) {
+    return /* @__PURE__ */ jsx7(Text8, { color: "yellow", children: "Checking..." });
   }
   if (step === STEPS2.CONFIRM) {
-    const item = changedItems[currentIdx];
+    const item = queue[currentIdx];
     return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
       /* @__PURE__ */ jsxs7(Warning, { children: [
         item.name,
-        ": local differs from latest"
+        ": local differs from ",
+        selectedCollection
       ] }),
-      /* @__PURE__ */ jsx7(DiffView, { patch: item.patch }),
+      /* @__PURE__ */ jsx7(DiffView, { patch: currentPatch }),
       /* @__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"
+    if (queue.length === 0 && missingNames.length === 0) {
+      return /* @__PURE__ */ jsx7(Success, { children: "Nothing to update." });
+    }
+    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      missingNames.length > 0 && /* @__PURE__ */ jsxs7(ErrorMsg, { children: [
+        "Not found: ",
+        missingNames.join(", ")
+      ] }),
+      skipReasons.length > 0 && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx7(Info, { children: "Skipped:" }),
+        skipReasons.map((s, i) => /* @__PURE__ */ jsxs7(Text8, { color: "gray", children: [
+          "  \u2022 ",
+          s.name,
+          " \u2014 ",
+          s.reason
+        ] }, `${s.name}-${i}`))
+      ] }),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Success, { children: [
+        updatedCount,
+        " updated, ",
+        installedCount,
+        " installed, ",
+        skippedCount,
+        " skipped"
+      ] }) })
     ] });
   }
   return null;
@@ -820,8 +1077,8 @@ function Update() {
 // 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 path5 from "path";
+import fs5 from "fs-extra";
 import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
 var STEPS3 = {
   TARGET: "target",
@@ -841,9 +1098,9 @@ function Remove({ skillNames }) {
     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)) {
+      const skillPath = path5.join(destRoot, targetConfig.skillsDir, name);
+      const agentPath = path5.join(destRoot, targetConfig.agentsDir, `${name}.md`);
+      if (!fs5.existsSync(skillPath) && !fs5.existsSync(agentPath)) {
         missing.push(name);
       }
     }
@@ -914,7 +1171,7 @@ 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: "update [skills...]", desc: "Update installed skills (interactive if no args)" },
     { name: "remove <skills>", desc: "Remove installed skills/agents" },
     { name: "help", desc: "Show this help message" }
   ];
@@ -923,6 +1180,7 @@ function Help() {
     "npx @hiver/skills add discuss-problem create-prd",
     "npx @hiver/skills list",
     "npx @hiver/skills update",
+    "npx @hiver/skills update build-component",
     "npx @hiver/skills remove discuss-problem"
   ];
   return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: [
@@ -959,7 +1217,7 @@ function App() {
     case "list":
       return /* @__PURE__ */ jsx9(List, {});
     case "update":
-      return /* @__PURE__ */ jsx9(Update, {});
+      return /* @__PURE__ */ jsx9(Update, { directSkills: restArgs.length > 0 ? restArgs : null });
     case "remove":
       if (restArgs.length === 0) {
         return /* @__PURE__ */ jsxs9(Text10, { color: "red", children: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiver/skills",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Shared Claude Code skills & agents for Hiver teams",
   "type": "module",
   "bin": {