claude-code-arcane 2.6.0 → 2.7.0

package/dist/cli.js

@@ -265,6 +265,113 @@ async function runInstallWizard(profiles, detections) {
   );
   return names;
 }
+async function runAddWizard(input) {
+  const installedProfiles = new Set(input.installedProfiles);
+  const installedSkills = new Set(input.installedSkills);
+  const addableProfiles = input.profiles.filter(
+    (pr) => !installedProfiles.has(pr.name)
+  );
+  const addableSkills = input.skills.filter((s) => !installedSkills.has(s.name));
+  p.intro(chalk.cyan("claude-code-arcane add"));
+  const current = input.installedProfiles.filter((n) => n !== "core");
+  p.note(
+    [
+      `Profiles: ${current.length > 0 ? chalk.green(current.join(", ")) : chalk.dim("core only")}`,
+      `Skills:   ${chalk.green(String(installedSkills.size))} installed, ${chalk.dim(`${addableSkills.length} available`)}`
+    ].join("\n"),
+    "Current installation"
+  );
+  if (addableProfiles.length === 0 && addableSkills.length === 0) {
+    p.outro(chalk.dim("Everything in the catalog is already installed."));
+    return null;
+  }
+  const kind = await pickKind(addableProfiles.length, addableSkills.length);
+  if (kind === null) return null;
+  const items = kind === "profiles" ? await pickProfiles(addableProfiles) : await pickSkills(addableSkills);
+  if (items === null) return null;
+  if (items.length === 0) {
+    p.outro(
+      chalk.dim(
+        "Nothing selected. Run again, or add directly: npx claude-code-arcane add +testing docker-setup"
+      )
+    );
+    return null;
+  }
+  const expr = items.join(" ");
+  const ok = await p.confirm({ message: `Add ${chalk.cyan(expr)}?` });
+  if (p.isCancel(ok) || !ok) {
+    p.cancel("Add cancelled.");
+    return null;
+  }
+  p.outro(
+    chalk.dim(`Next time, skip the menu: npx claude-code-arcane add ${expr}`)
+  );
+  return items;
+}
+async function pickKind(profileCount, skillCount) {
+  if (profileCount === 0) return "skills";
+  if (skillCount === 0) return "profiles";
+  const kind = await p.select({
+    message: "What do you want to add?",
+    options: [
+      {
+        value: "profiles",
+        label: "Profiles",
+        hint: `${profileCount} not installed \u2014 brings its skills, rules and agents`
+      },
+      {
+        value: "skills",
+        label: "Individual skills",
+        hint: `${skillCount} not installed \u2014 search by name`
+      }
+    ]
+  });
+  if (p.isCancel(kind)) {
+    p.cancel("Add cancelled.");
+    return null;
+  }
+  return kind;
+}
+async function pickProfiles(addable) {
+  const options = {};
+  for (const group of groupByCategory(addable)) {
+    options[group.label] = group.profiles.map((pr) => ({
+      value: pr.name,
+      label: pr.name,
+      hint: hint(pr.description)
+    }));
+  }
+  const selected = await p.groupMultiselect({
+    message: "Select profiles to add (space to toggle, enter to confirm)",
+    options,
+    required: false
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Add cancelled.");
+    return null;
+  }
+  return selected.map((name) => `+${name}`);
+}
+async function pickSkills(addable) {
+  const selected = await p.autocompleteMultiselect({
+    message: "Search skills to add (type to filter, space to toggle)",
+    options: addable.map((s) => ({
+      value: s.name,
+      label: s.name,
+      hint: hint(s.description)
+    })),
+    required: false
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Add cancelled.");
+    return null;
+  }
+  return selected;
+}
+function hint(description, max = 90) {
+  const flat = description.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 3)}...` : flat;
+}
 
 // src/installer.ts
 import fs6 from "fs";
@@ -1528,10 +1635,53 @@ Installing profile: ${chalk2.cyan(profileExpr)}`)
 }
 
 // src/commands/add.ts
+import fs10 from "fs";
+import path13 from "path";
+import chalk3 from "chalk";
+
+// src/skills-catalog.ts
 import fs9 from "fs";
 import path12 from "path";
-import chalk3 from "chalk";
-async function addCommand(items) {
+var FRONTMATTER_BYTES = 4096;
+function listSkills(skillsDir) {
+  if (!fs9.existsSync(skillsDir)) return [];
+  return fs9.readdirSync(skillsDir, { withFileTypes: true }).filter(
+    (d) => d.isDirectory() && !d.name.startsWith("_") && fs9.existsSync(path12.join(skillsDir, d.name, "SKILL.md"))
+  ).map((d) => ({
+    name: d.name,
+    description: readDescription(path12.join(skillsDir, d.name, "SKILL.md"))
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function readDescription(skillFile) {
+  const head = readHead(skillFile);
+  const lines = head.split(/\r?\n/);
+  const idx = lines.findIndex((l) => /^description:/.test(l));
+  if (idx === -1) return "";
+  const inline = lines[idx].slice("description:".length).trim();
+  if (inline === "|" || inline === ">" || /^[|>][-+]?$/.test(inline)) {
+    const block = [];
+    for (const line of lines.slice(idx + 1)) {
+      if (line.trim() === "") continue;
+      if (!/^\s/.test(line)) break;
+      block.push(line.trim());
+    }
+    return block.join(" ");
+  }
+  return inline.replace(/^["']|["']$/g, "").trim();
+}
+function readHead(file) {
+  const fd = fs9.openSync(file, "r");
+  try {
+    const buf = Buffer.alloc(FRONTMATTER_BYTES);
+    const read = fs9.readSync(fd, buf, 0, FRONTMATTER_BYTES, 0);
+    return buf.subarray(0, read).toString("utf-8");
+  } finally {
+    fs9.closeSync(fd);
+  }
+}
+
+// src/commands/add.ts
+async function addCommand(items = []) {
   const target = process.cwd();
   const source = await resolveContentSource({ quiet: true });
   const root = await source.getContentRoot();
@@ -1544,7 +1694,21 @@ async function addCommand(items) {
     );
     process.exit(1);
   }
-  const claudeDir = path12.join(target, ".claude");
+  if (items.length === 0) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY)) {
+      printCatalog(root, manifest.profiles, manifest.installed_skills);
+      return;
+    }
+    const selected = await runAddWizard({
+      profiles: listProfiles(path13.join(root, "profiles")),
+      skills: listSkills(path13.join(root, "skills")),
+      installedProfiles: manifest.profiles,
+      installedSkills: manifest.installed_skills
+    });
+    if (!selected) return;
+    items = selected;
+  }
+  const claudeDir = path13.join(target, ".claude");
   const added = [];
   const skipped = [];
   const notFound = [];
@@ -1554,8 +1718,8 @@ async function addCommand(items) {
   for (const item of items) {
     if (item.startsWith("+")) {
       const profileName = item.slice(1);
-      const profilePath = path12.join(root, "profiles", `${profileName}.yaml`);
-      if (!fs9.existsSync(profilePath)) {
+      const profilePath = path13.join(root, "profiles", `${profileName}.yaml`);
+      if (!fs10.existsSync(profilePath)) {
         console.error(chalk3.red(`  Profile '${profileName}' not found`));
         continue;
       }
@@ -1568,10 +1732,10 @@ async function addCommand(items) {
       }
       for (const rule of profile.rules.universal) {
         if (!manifest.installed_rules.includes(rule)) {
-          const src = path12.join(root, "rules", `${rule}.md`);
-          if (fs9.existsSync(src)) {
-            ensureDir(path12.join(claudeDir, "rules"));
-            fs9.copyFileSync(src, path12.join(claudeDir, "rules", `${rule}.md`));
+          const src = path13.join(root, "rules", `${rule}.md`);
+          if (fs10.existsSync(src)) {
+            ensureDir(path13.join(claudeDir, "rules"));
+            fs10.copyFileSync(src, path13.join(claudeDir, "rules", `${rule}.md`));
             manifest.installed_rules.push(rule);
             addedRules.push(rule);
           }
@@ -1579,10 +1743,10 @@ async function addCommand(items) {
       }
       for (const rule of profile.rules.gamedev) {
         if (!manifest.installed_rules.includes(rule)) {
-          const src = path12.join(root, "rules", "gamedev", `${rule}.md`);
-          if (fs9.existsSync(src)) {
-            ensureDir(path12.join(claudeDir, "rules"));
-            fs9.copyFileSync(src, path12.join(claudeDir, "rules", `${rule}.md`));
+          const src = path13.join(root, "rules", "gamedev", `${rule}.md`);
+          if (fs10.existsSync(src)) {
+            ensureDir(path13.join(claudeDir, "rules"));
+            fs10.copyFileSync(src, path13.join(claudeDir, "rules", `${rule}.md`));
             manifest.installed_rules.push(rule);
             addedRules.push(rule);
           }
@@ -1590,9 +1754,9 @@ async function addCommand(items) {
       }
       for (const agentDir of profile.agents) {
         if (!manifest.installed_agents.includes(agentDir)) {
-          const src = path12.join(root, "agents", agentDir);
-          if (fs9.existsSync(src)) {
-            const dst = path12.join(claudeDir, "agents", agentDir);
+          const src = path13.join(root, "agents", agentDir);
+          if (fs10.existsSync(src)) {
+            const dst = path13.join(claudeDir, "agents", agentDir);
             copyDirSync(src, dst);
             manifest.installed_agents.push(agentDir);
             addedAgents.push(agentDir);
@@ -1600,9 +1764,9 @@ async function addCommand(items) {
         }
       }
       if (profileName === "statusline") {
-        const statuslineSrc = path12.join(root, "hooks", "statusline.sh");
-        if (fs9.existsSync(statuslineSrc)) {
-          fs9.copyFileSync(statuslineSrc, path12.join(claudeDir, "statusline.sh"));
+        const statuslineSrc = path13.join(root, "hooks", "statusline.sh");
+        if (fs10.existsSync(statuslineSrc)) {
+          fs10.copyFileSync(statuslineSrc, path13.join(claudeDir, "statusline.sh"));
           statuslineAdded = true;
         }
       }
@@ -1636,8 +1800,12 @@ async function addCommand(items) {
   };
   writeManifest(target, merged, manifest.profile_command, root);
   const totalAdded = added.length + addedRules.length + addedAgents.length + (statuslineAdded ? 1 : 0);
-  console.log(chalk3.bold(`
-Added ${totalAdded} items:`));
+  console.log(
+    chalk3.bold(
+      totalAdded === 0 ? "\nNothing added." : `
+Added ${totalAdded} items:`
+    )
+  );
   for (const s of added) console.log(chalk3.green(`  [ok] skill: ${s}`));
   for (const r of addedRules) console.log(chalk3.green(`  [ok] rule: ${r}`));
   for (const a of addedAgents) console.log(chalk3.green(`  [ok] agents: ${a}/`));
@@ -1646,18 +1814,54 @@ Added ${totalAdded} items:`));
     console.log(chalk3.dim(`  [skip] ${s} (already installed)`));
   for (const s of notFound)
     console.log(chalk3.red(`  [miss] ${s} (not found in source)`));
+  if (totalAdded > 0) {
+    console.log(
+      chalk3.dim(
+        `
+  Now installed: ${manifest.installed_skills.length} skills, ${manifest.installed_rules.length} rules, ${manifest.installed_agents.length} agents.`
+      )
+    );
+  }
+}
+function printCatalog(root, installedProfiles, installedSkills) {
+  const profiles = listProfiles(path13.join(root, "profiles")).filter(
+    (pr) => !installedProfiles.includes(pr.name)
+  );
+  const skills = listSkills(path13.join(root, "skills")).filter(
+    (sk) => !installedSkills.includes(sk.name)
+  );
+  if (profiles.length === 0 && skills.length === 0) {
+    console.log(chalk3.dim("\nEverything in the catalog is already installed.\n"));
+    return;
+  }
+  console.log(chalk3.bold("\nProfiles you can add:\n"));
+  for (const group of groupByCategory(profiles)) {
+    console.log(chalk3.cyan(`  ${group.label}:`));
+    for (const pr of group.profiles) {
+      console.log(
+        `    ${chalk3.green(`+${pr.name}`.padEnd(20))} ${pr.description}`
+      );
+    }
+    console.log();
+  }
+  console.log(
+    chalk3.dim(`  Plus ${skills.length} individual skills \u2014 see \`arcane list\`.`)
+  );
+  console.log(
+    chalk3.dim("  Usage: npx claude-code-arcane add +testing docker-setup\n")
+  );
 }
 function addSkill(root, target, skill, installed) {
   if (installed.includes(skill)) return "skipped";
-  const src = path12.join(root, "skills", skill);
-  if (!fs9.existsSync(src)) return "not-found";
-  const dst = path12.join(target, ".claude", "skills", skill);
+  const src = path13.join(root, "skills", skill);
+  if (!fs10.existsSync(src)) return "not-found";
+  const dst = path13.join(target, ".claude", "skills", skill);
   copyDirSync(src, dst);
   return "added";
 }
 function mergePermissions(claudeDir, newPerms) {
-  const settingsPath = path12.join(claudeDir, "settings.json");
-  if (!fs9.existsSync(settingsPath)) return;
+  const settingsPath = path13.join(claudeDir, "settings.json");
+  if (!fs10.existsSync(settingsPath)) return;
   const settings = readJsonSync(settingsPath);
   const perms = settings.permissions ?? { allow: [], deny: [] };
   const allowSet = new Set(perms.allow);
@@ -1670,8 +1874,8 @@ function mergePermissions(claudeDir, newPerms) {
   writeJsonSync(settingsPath, settings);
 }
 function addStatuslineToSettings(claudeDir) {
-  const settingsPath = path12.join(claudeDir, "settings.json");
-  if (!fs9.existsSync(settingsPath)) return;
+  const settingsPath = path13.join(claudeDir, "settings.json");
+  if (!fs10.existsSync(settingsPath)) return;
   const settings = readJsonSync(settingsPath);
   if (settings.statusLine) return;
   settings.statusLine = {
@@ -1682,8 +1886,8 @@ function addStatuslineToSettings(claudeDir) {
 }
 
 // src/commands/remove.ts
-import fs10 from "fs";
-import path13 from "path";
+import fs11 from "fs";
+import path14 from "path";
 import chalk4 from "chalk";
 var CORE_SKILLS = [
   "commit",
@@ -1748,7 +1952,7 @@ async function removeCommand(items, opts = {}) {
   }
   manifest.total_skills = manifest.installed_skills.length;
   manifest.total_rules = manifest.installed_rules.length;
-  const mp = path13.join(target, ".claude", "arcane-manifest.json");
+  const mp = path14.join(target, ".claude", "arcane-manifest.json");
   writeJsonSync(mp, manifest);
   const totalRemoved = removedSkills.length + removedAgents.length + removedProfiles.length;
   console.log(chalk4.bold(`
@@ -1769,9 +1973,9 @@ function removeSkill(target, skill, manifest) {
     );
     return "skipped";
   }
-  const skillDir = path13.join(target, ".claude", "skills", skill);
-  if (!fs10.existsSync(skillDir)) return "skipped";
-  fs10.rmSync(skillDir, { recursive: true, force: true });
+  const skillDir = path14.join(target, ".claude", "skills", skill);
+  if (!fs11.existsSync(skillDir)) return "skipped";
+  fs11.rmSync(skillDir, { recursive: true, force: true });
   manifest.installed_skills = manifest.installed_skills.filter(
     (s) => s !== skill
   );
@@ -1790,8 +1994,8 @@ function removeProfile(root, target, profileName, manifest) {
     );
     return { removed: false, skills: [], agents: [] };
   }
-  const profilePath = path13.join(root, "profiles", `${profileName}.yaml`);
-  if (!fs10.existsSync(profilePath)) {
+  const profilePath = path14.join(root, "profiles", `${profileName}.yaml`);
+  if (!fs11.existsSync(profilePath)) {
     console.warn(
       chalk4.yellow(`  WARNING: Profile '${profileName}.yaml' not found.`)
     );
@@ -1805,8 +2009,8 @@ function removeProfile(root, target, profileName, manifest) {
   const sharedAgents = /* @__PURE__ */ new Set();
   const sharedRules = /* @__PURE__ */ new Set();
   for (const rp of remainingProfiles) {
-    const rpPath = path13.join(root, "profiles", `${rp}.yaml`);
-    if (!fs10.existsSync(rpPath)) continue;
+    const rpPath = path14.join(root, "profiles", `${rp}.yaml`);
+    if (!fs11.existsSync(rpPath)) continue;
     const rpDef = parseProfile(rpPath);
     rpDef.skills.forEach((s) => sharedSkills.add(s));
     rpDef.agents.forEach((a) => sharedAgents.add(a));
@@ -1817,9 +2021,9 @@ function removeProfile(root, target, profileName, manifest) {
   for (const skill of profile.skills) {
     if (sharedSkills.has(skill)) continue;
     if (CORE_SKILLS.includes(skill)) continue;
-    const skillDir = path13.join(target, ".claude", "skills", skill);
-    if (fs10.existsSync(skillDir)) {
-      fs10.rmSync(skillDir, { recursive: true, force: true });
+    const skillDir = path14.join(target, ".claude", "skills", skill);
+    if (fs11.existsSync(skillDir)) {
+      fs11.rmSync(skillDir, { recursive: true, force: true });
       removedSkills.push(skill);
     }
     manifest.installed_skills = manifest.installed_skills.filter(
@@ -1829,9 +2033,9 @@ function removeProfile(root, target, profileName, manifest) {
   const removedAgents = [];
   for (const agent of profile.agents) {
     if (sharedAgents.has(agent)) continue;
-    const agentDir = path13.join(target, ".claude", "agents", agent);
-    if (fs10.existsSync(agentDir)) {
-      fs10.rmSync(agentDir, { recursive: true, force: true });
+    const agentDir = path14.join(target, ".claude", "agents", agent);
+    if (fs11.existsSync(agentDir)) {
+      fs11.rmSync(agentDir, { recursive: true, force: true });
       removedAgents.push(agent);
     }
     manifest.installed_agents = manifest.installed_agents.filter(
@@ -1843,44 +2047,44 @@ function removeProfile(root, target, profileName, manifest) {
     ...profile.rules.gamedev
   ]) {
     if (sharedRules.has(rule)) continue;
-    const ruleFile = path13.join(target, ".claude", "rules", `${rule}.md`);
-    if (fs10.existsSync(ruleFile)) {
-      fs10.rmSync(ruleFile);
+    const ruleFile = path14.join(target, ".claude", "rules", `${rule}.md`);
+    if (fs11.existsSync(ruleFile)) {
+      fs11.rmSync(ruleFile);
     }
     manifest.installed_rules = manifest.installed_rules.filter(
       (r) => r !== rule
     );
   }
   if (profileName === "statusline") {
-    const statuslineFile = path13.join(target, ".claude", "statusline.sh");
-    if (fs10.existsSync(statuslineFile)) {
-      fs10.rmSync(statuslineFile);
+    const statuslineFile = path14.join(target, ".claude", "statusline.sh");
+    if (fs11.existsSync(statuslineFile)) {
+      fs11.rmSync(statuslineFile);
     }
-    removeStatuslineFromSettings(path13.join(target, ".claude"));
+    removeStatuslineFromSettings(path14.join(target, ".claude"));
   }
   manifest.profiles = remainingProfiles;
   manifest.profile_command = remainingProfiles.filter((p2) => p2 !== "core").join("+");
   return { removed: true, skills: removedSkills, agents: removedAgents };
 }
 function removeStatuslineFromSettings(claudeDir) {
-  const settingsPath = path13.join(claudeDir, "settings.json");
-  if (!fs10.existsSync(settingsPath)) return;
-  const settings = JSON.parse(fs10.readFileSync(settingsPath, "utf-8"));
+  const settingsPath = path14.join(claudeDir, "settings.json");
+  if (!fs11.existsSync(settingsPath)) return;
+  const settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
   if (settings.statusLine) {
     delete settings.statusLine;
-    fs10.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    fs11.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   }
 }
 
 // src/commands/list.ts
-import fs11 from "fs";
-import path14 from "path";
+import fs12 from "fs";
+import path15 from "path";
 import chalk5 from "chalk";
 async function listCommand() {
   const source = await resolveContentSource({ quiet: true });
   const root = await source.getContentRoot();
-  const profilesDir = path14.join(root, "profiles");
-  const skillsDir = path14.join(root, "skills");
+  const profilesDir = path15.join(root, "profiles");
+  const skillsDir = path15.join(root, "skills");
   const target = process.cwd();
   const manifest = readManifest(target);
   const profiles = listProfiles(profilesDir);
@@ -1897,10 +2101,8 @@ async function listCommand() {
     }
     console.log();
   }
-  if (fs11.existsSync(skillsDir)) {
-    const allSkills = fs11.readdirSync(skillsDir, { withFileTypes: true }).filter(
-      (d) => d.isDirectory() && !d.name.startsWith("_") && fs11.existsSync(path14.join(skillsDir, d.name, "SKILL.md"))
-    ).map((d) => d.name).sort();
+  if (fs12.existsSync(skillsDir)) {
+    const allSkills = listSkills(skillsDir).map((s) => s.name);
     console.log(chalk5.bold(`
 === Skills (${allSkills.length}) ===
 `));
@@ -1966,8 +2168,8 @@ async function statusCommand() {
 }
 
 // src/commands/update.ts
-import fs12 from "fs";
-import path15 from "path";
+import fs13 from "fs";
+import path16 from "path";
 import os4 from "os";
 import chalk7 from "chalk";
 
@@ -2039,12 +2241,12 @@ async function updateCommand(opts) {
     }
   }
   const cwd = process.cwd();
-  if (fs12.existsSync(manifestPath(cwd))) {
+  if (fs13.existsSync(manifestPath(cwd))) {
     registerInstallation(cwd);
   }
   const targets = pruneRegistry().map((e) => e.path);
   const globalTarget = os4.homedir();
-  if (!process.env.VITEST && fs12.existsSync(manifestPath(globalTarget)) && !targets.includes(globalTarget)) {
+  if (!process.env.VITEST && fs13.existsSync(manifestPath(globalTarget)) && !targets.includes(globalTarget)) {
     targets.push(globalTarget);
   }
   if (targets.length === 0) {
@@ -2120,11 +2322,11 @@ Update available: ${chalk7.red(installedVersion)} -> ${chalk7.green(currentVersi
     );
   }
   const profileNames = manifest.profile_command.split("+").filter(Boolean);
-  const profilesDir = path15.join(root, "profiles");
+  const profilesDir = path16.join(root, "profiles");
   const merged = mergeProfiles(profilesDir, profileNames);
   const allRules = [...merged.rules.universal, ...merged.rules.gamedev];
   const sourceHashes = computeSourceHashes(root, merged.skills, allRules, merged.agents);
-  const claudeDir = path15.join(target, ".claude");
+  const claudeDir = path16.join(target, ".claude");
   const installedHashes = computeContentHashes(claudeDir);
   const items = computeUpdatePlan(
     manifest.content_hashes ?? null,
@@ -2317,48 +2519,48 @@ function applyUpdates(items, root, claudeDir, merged, force) {
 function applyItem(item, root, claudeDir) {
   const src = getSourcePath(item, root);
   const dst = getInstalledPath(item, claudeDir);
-  if (!src || !fs12.existsSync(src)) return;
+  if (!src || !fs13.existsSync(src)) return;
   if (item.type === "skill" || item.type === "agent") {
-    if (fs12.existsSync(dst)) {
-      fs12.rmSync(dst, { recursive: true, force: true });
+    if (fs13.existsSync(dst)) {
+      fs13.rmSync(dst, { recursive: true, force: true });
     }
     copyDirSync(src, dst);
   } else {
-    const dir = path15.dirname(dst);
-    if (!fs12.existsSync(dir)) {
-      fs12.mkdirSync(dir, { recursive: true });
+    const dir = path16.dirname(dst);
+    if (!fs13.existsSync(dir)) {
+      fs13.mkdirSync(dir, { recursive: true });
     }
-    fs12.copyFileSync(src, dst);
+    fs13.copyFileSync(src, dst);
   }
 }
 function backupItem(item, claudeDir) {
   const installed = getInstalledPath(item, claudeDir);
-  if (!fs12.existsSync(installed)) return;
+  if (!fs13.existsSync(installed)) return;
   const backupPath = installed + ".bak";
-  if (fs12.existsSync(backupPath)) {
-    fs12.rmSync(backupPath, { recursive: true, force: true });
+  if (fs13.existsSync(backupPath)) {
+    fs13.rmSync(backupPath, { recursive: true, force: true });
   }
-  fs12.renameSync(installed, backupPath);
+  fs13.renameSync(installed, backupPath);
 }
 function removeItem(item, claudeDir) {
   const installed = getInstalledPath(item, claudeDir);
-  if (fs12.existsSync(installed)) {
-    fs12.rmSync(installed, { recursive: true, force: true });
+  if (fs13.existsSync(installed)) {
+    fs13.rmSync(installed, { recursive: true, force: true });
   }
 }
 function getSourcePath(item, root) {
   switch (item.type) {
     case "skill":
-      return path15.join(root, "skills", item.name);
+      return path16.join(root, "skills", item.name);
     case "rule": {
-      const direct = path15.join(root, "rules", item.name);
-      if (fs12.existsSync(direct)) return direct;
-      return path15.join(root, "rules", "gamedev", item.name);
+      const direct = path16.join(root, "rules", item.name);
+      if (fs13.existsSync(direct)) return direct;
+      return path16.join(root, "rules", "gamedev", item.name);
     }
     case "agent":
-      return path15.join(root, "agents", item.name);
+      return path16.join(root, "agents", item.name);
     case "hook":
-      return path15.join(root, "hooks", item.name);
+      return path16.join(root, "hooks", item.name);
     default:
       return null;
   }
@@ -2366,13 +2568,13 @@ function getSourcePath(item, root) {
 function getInstalledPath(item, claudeDir) {
   switch (item.type) {
     case "skill":
-      return path15.join(claudeDir, "skills", item.name);
+      return path16.join(claudeDir, "skills", item.name);
     case "rule":
-      return path15.join(claudeDir, "rules", item.name);
+      return path16.join(claudeDir, "rules", item.name);
     case "agent":
-      return path15.join(claudeDir, "agents", item.name);
+      return path16.join(claudeDir, "agents", item.name);
     case "hook":
-      return path15.join(claudeDir, "hooks", item.name);
+      return path16.join(claudeDir, "hooks", item.name);
   }
 }
 
@@ -2407,8 +2609,8 @@ async function cleanCommand(opts) {
 }
 
 // src/commands/worktree.ts
-import fs13 from "fs";
-import path16 from "path";
+import fs14 from "fs";
+import path17 from "path";
 import { execSync as execSync2 } from "child_process";
 import chalk9 from "chalk";
 async function worktreeCommand(branch, opts) {
@@ -2419,8 +2621,8 @@ async function worktreeCommand(branch, opts) {
     process.exit(1);
   }
   const repoRoot = wtInfo.isWorktree ? wtInfo.mainWorktreePath : cwd;
-  const worktreePath = opts.path ? path16.resolve(opts.path) : defaultWorktreePath(repoRoot, branch);
-  if (fs13.existsSync(worktreePath)) {
+  const worktreePath = opts.path ? path17.resolve(opts.path) : defaultWorktreePath(repoRoot, branch);
+  if (fs14.existsSync(worktreePath)) {
     console.error(
       chalk9.red(`Path already exists: ${worktreePath}`)
     );
@@ -2467,7 +2669,7 @@ async function worktreeCommand(branch, opts) {
   }
   console.log("  Installing Arcane...");
   const root = getPackageRoot();
-  const profilesDir = path16.join(root, "profiles");
+  const profilesDir = path17.join(root, "profiles");
   const profileNames = profileExpr.split("+").filter(Boolean);
   const merged = mergeProfiles(profilesDir, profileNames);
   const shareFrom = opts.share !== false ? cwd : void 0;
@@ -2503,13 +2705,13 @@ async function worktreeCommand(branch, opts) {
     }
   }
   if (opts.isolate) {
-    const isolateScript = path16.join(
+    const isolateScript = path17.join(
       worktreePath,
       ".claude",
       "skills",
       "worktree-isolation"
     );
-    if (fs13.existsSync(isolateScript)) {
+    if (fs14.existsSync(isolateScript)) {
       console.log("  Applying worktree isolation...");
       try {
         execSync2(
@@ -2544,13 +2746,13 @@ async function worktreeCommand(branch, opts) {
 }
 
 // src/commands/global.ts
-import fs14 from "fs";
-import path17 from "path";
+import fs15 from "fs";
+import path18 from "path";
 import os5 from "os";
 import chalk10 from "chalk";
-var CLAUDE_HOME = path17.join(os5.homedir(), ".claude");
-var SCRIPTS_DIR = path17.join(CLAUDE_HOME, "scripts", "worktree-isolation");
-var SETTINGS_PATH = path17.join(CLAUDE_HOME, "settings.json");
+var CLAUDE_HOME = path18.join(os5.homedir(), ".claude");
+var SCRIPTS_DIR = path18.join(CLAUDE_HOME, "scripts", "worktree-isolation");
+var SETTINGS_PATH = path18.join(CLAUDE_HOME, "settings.json");
 async function globalCommand(opts) {
   if (opts.status) {
     showStatus();
@@ -2564,8 +2766,8 @@ async function globalCommand(opts) {
 }
 function showStatus() {
   console.log(chalk10.bold("\n=== Arcane Global Status ===\n"));
-  const hasScripts = fs14.existsSync(
-    path17.join(SCRIPTS_DIR, "apply.py")
+  const hasScripts = fs15.existsSync(
+    path18.join(SCRIPTS_DIR, "apply.py")
   );
   console.log(
     `  Worktree scripts: ${hasScripts ? chalk10.green("installed") : chalk10.dim("not installed")}`
@@ -2583,32 +2785,32 @@ function showStatus() {
 function installGlobal() {
   console.log(chalk10.bold("\nInstalling Arcane global hooks...\n"));
   const root = getPackageRoot();
-  const scriptsSrc = path17.join(
+  const scriptsSrc = path18.join(
     root,
     "skills",
     "worktree-isolation",
     "scripts"
   );
-  if (!fs14.existsSync(scriptsSrc)) {
+  if (!fs15.existsSync(scriptsSrc)) {
     console.error(
       chalk10.red("  worktree-isolation scripts not found in package.")
     );
     process.exit(1);
   }
-  fs14.mkdirSync(SCRIPTS_DIR, { recursive: true });
+  fs15.mkdirSync(SCRIPTS_DIR, { recursive: true });
   for (const file of ["apply.py", "lib.py"]) {
-    const src = path17.join(scriptsSrc, file);
-    const dst = path17.join(SCRIPTS_DIR, file);
-    if (!fs14.existsSync(src)) {
+    const src = path18.join(scriptsSrc, file);
+    const dst = path18.join(SCRIPTS_DIR, file);
+    if (!fs15.existsSync(src)) {
       console.warn(chalk10.yellow(`  WARN: ${file} not found, skipping`));
       continue;
     }
-    if (fs14.existsSync(dst) && fs14.readFileSync(src).equals(fs14.readFileSync(dst))) {
+    if (fs15.existsSync(dst) && fs15.readFileSync(src).equals(fs15.readFileSync(dst))) {
       console.log(chalk10.dim(`  [skip] ${file} (already up-to-date)`));
     } else {
-      fs14.copyFileSync(src, dst);
+      fs15.copyFileSync(src, dst);
       if (process.platform !== "win32") {
-        fs14.chmodSync(dst, 493);
+        fs15.chmodSync(dst, 493);
       }
       console.log(chalk10.green(`  [ok] ${file} -> ${SCRIPTS_DIR}`));
     }
@@ -2632,8 +2834,8 @@ function installGlobal() {
 }
 function removeGlobal() {
   console.log(chalk10.bold("\nRemoving Arcane global hooks...\n"));
-  if (fs14.existsSync(SCRIPTS_DIR)) {
-    fs14.rmSync(SCRIPTS_DIR, { recursive: true, force: true });
+  if (fs15.existsSync(SCRIPTS_DIR)) {
+    fs15.rmSync(SCRIPTS_DIR, { recursive: true, force: true });
     console.log(chalk10.green("  [ok] Removed worktree-isolation scripts"));
   } else {
     console.log(chalk10.dim("  [skip] Scripts not found"));
@@ -2647,16 +2849,16 @@ function removeGlobal() {
   console.log(chalk10.bold.green("\n  Global hooks removed.\n"));
 }
 function readSettings() {
-  if (!fs14.existsSync(SETTINGS_PATH)) return {};
+  if (!fs15.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs14.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs15.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  fs14.mkdirSync(path17.dirname(SETTINGS_PATH), { recursive: true });
-  fs14.writeFileSync(
+  fs15.mkdirSync(path18.dirname(SETTINGS_PATH), { recursive: true });
+  fs15.writeFileSync(
     SETTINGS_PATH,
     JSON.stringify(settings, null, 2) + "\n",
     "utf-8"
@@ -2713,15 +2915,34 @@ function removeHookFromSettings() {
 }
 
 // src/update-check.ts
-import fs15 from "fs";
-import path18 from "path";
+import fs16 from "fs";
+import path19 from "path";
 import os6 from "os";
 import chalk11 from "chalk";
-var CHECK_FILE = path18.join(os6.homedir(), ".arcane", "last-check.json");
+var CHECK_FILE = path19.join(os6.homedir(), ".arcane", "last-check.json");
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 var GITHUB_OWNER2 = "SebastianLuser";
 var GITHUB_REPO2 = "Claude-Code-Arcane";
 var GITHUB_BRANCH2 = "main";
+var PACKAGE_NAME2 = "claude-code-arcane";
+var SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
+function compareSemver(a, b) {
+  const release = (v) => v.trim().replace(/^v/, "").split(/[-+]/)[0];
+  const parts = (v) => release(v).split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const [aMajor = 0, aMinor = 0, aPatch = 0] = parts(a);
+  const [bMajor = 0, bMinor = 0, bPatch = 0] = parts(b);
+  if (aMajor !== bMajor) return aMajor - bMajor;
+  if (aMinor !== bMinor) return aMinor - bMinor;
+  if (aPatch !== bPatch) return aPatch - bPatch;
+  const aPre = /-/.test(a.trim());
+  const bPre = /-/.test(b.trim());
+  if (aPre !== bPre) return aPre ? -1 : 1;
+  return 0;
+}
+function isContentUpdateAvailable(localVersion, remoteSha) {
+  if (!SHA_PATTERN.test(localVersion)) return false;
+  return !remoteSha.startsWith(localVersion) && !localVersion.startsWith(remoteSha);
+}
 async function checkForUpdates(opts = {}) {
   try {
     const cached = readCachedCheck();
@@ -2729,40 +2950,62 @@ async function checkForUpdates(opts = {}) {
       const age = Date.now() - new Date(cached.checked_at).getTime();
       if (age < CHECK_INTERVAL_MS) {
         if (cached.update_available && !opts.quiet) {
-          printUpdateNotice(cached.local_version, cached.remote_sha);
+          printUpdateNotice(cached);
         }
         return cached.update_available;
       }
     }
     const manifest = readManifest(process.cwd());
     const localVersion = manifest?.source_version ?? manifest?.arcane_version ?? "unknown";
-    const remoteSha = await getLatestCommitSha();
-    if (!remoteSha) return false;
-    const shortSha = remoteSha.substring(0, 12);
-    const updateAvailable = localVersion !== shortSha && !remoteSha.startsWith(localVersion);
+    const cliVersion = getPackageVersion();
+    const [remoteSha, latestCli] = await Promise.all([
+      getLatestCommitSha(),
+      getLatestNpmVersion()
+    ]);
+    const shortSha = remoteSha ? remoteSha.substring(0, 12) : cached?.remote_sha ?? "";
+    const contentUpdate = shortSha !== "" && isContentUpdateAvailable(localVersion, shortSha);
+    const cliUpdate = latestCli !== null && compareSemver(latestCli, cliVersion) > 0;
+    if (!remoteSha && latestCli === null) return false;
     const result = {
       checked_at: (/* @__PURE__ */ new Date()).toISOString(),
       local_version: localVersion,
       remote_sha: shortSha,
-      update_available: updateAvailable
+      update_available: contentUpdate || cliUpdate,
+      content_update_available: contentUpdate,
+      cli_version: cliVersion,
+      latest_cli_version: latestCli ?? void 0,
+      cli_update_available: cliUpdate
     };
     writeCachedCheck(result);
-    if (updateAvailable && !opts.quiet) {
-      printUpdateNotice(localVersion, shortSha);
+    if (result.update_available && !opts.quiet) {
+      printUpdateNotice(result);
     }
-    return updateAvailable;
+    return result.update_available;
   } catch {
     return false;
   }
 }
-function printUpdateNotice(localVersion, remoteSha) {
-  console.log(
-    chalk11.yellow(`
-  Arcane update available: ${localVersion} \u2192 ${remoteSha}`)
-  );
-  console.log(
-    chalk11.dim("  Run: arcane update (--dry-run to preview)\n")
-  );
+function printUpdateNotice(result) {
+  if (result.cli_update_available) {
+    console.log(
+      chalk11.yellow(
+        `
+  Arcane CLI update: ${result.cli_version} \u2192 ${result.latest_cli_version}`
+      )
+    );
+    const how = isGloballyInstalled() ? `  Run: npm install -g ${PACKAGE_NAME2}@latest` : `  You are on an older CLI. Latest: ${PACKAGE_NAME2}@${result.latest_cli_version}`;
+    console.log(chalk11.dim(how));
+  }
+  if (result.content_update_available ?? true) {
+    console.log(
+      chalk11.yellow(
+        `
+  Arcane content update: ${result.local_version} \u2192 ${result.remote_sha}`
+      )
+    );
+    console.log(chalk11.dim("  Run: arcane update (--dry-run to preview)"));
+  }
+  console.log("");
 }
 async function getLatestCommitSha() {
   try {
@@ -2783,21 +3026,37 @@ async function getLatestCommitSha() {
     return null;
   }
 }
+async function getLatestNpmVersion() {
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${PACKAGE_NAME2}/latest`,
+      {
+        headers: { "User-Agent": "arcane-cli", Accept: "application/json" },
+        signal: AbortSignal.timeout(5e3)
+      }
+    );
+    if (!response.ok) return null;
+    const data = await response.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
 function readCachedCheck() {
   try {
-    if (!fs15.existsSync(CHECK_FILE)) return null;
-    return JSON.parse(fs15.readFileSync(CHECK_FILE, "utf-8"));
+    if (!fs16.existsSync(CHECK_FILE)) return null;
+    return JSON.parse(fs16.readFileSync(CHECK_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCachedCheck(result) {
   try {
-    const dir = path18.dirname(CHECK_FILE);
-    if (!fs15.existsSync(dir)) {
-      fs15.mkdirSync(dir, { recursive: true });
+    const dir = path19.dirname(CHECK_FILE);
+    if (!fs16.existsSync(dir)) {
+      fs16.mkdirSync(dir, { recursive: true });
     }
-    fs15.writeFileSync(CHECK_FILE, JSON.stringify(result, null, 2) + "\n");
+    fs16.writeFileSync(CHECK_FILE, JSON.stringify(result, null, 2) + "\n");
   } catch {
   }
 }
@@ -2815,9 +3074,9 @@ program.command("install [profile]").description(
 ).option("--source <source>", "Content source: auto, github, or bundled", "auto").action(async (profile, opts) => {
   await installCommand(profile, opts);
 });
-program.command("add <items...>").description(
-  "Add skills or profiles. Use +profileName for profiles, skillName for individual skills."
-).action(async (items) => {
+program.command("add [items...]").description(
+  "Add skills or profiles. Use +profileName for profiles, skillName for individual skills. Without args, opens an interactive picker."
+).action(async (items = []) => {
   await addCommand(items);
 });
 program.command("remove <items...>").description(