sundial-hub 0.0.1

package/dist/index.js

@@ -0,0 +1,1593 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk9 from "chalk";
+import { createRequire } from "module";
+
+// src/constants.ts
+var COMMANDS = ["add", "remove", "list", "show", "config"];
+var AGENTS = [
+  { name: "Claude Code", flag: "claude", folderName: ".claude" },
+  { name: "Codex", flag: "codex", folderName: ".codex" },
+  { name: "Gemini", flag: "gemini", folderName: ".gemini" }
+];
+
+// src/core/agents.ts
+var SUPPORTED_AGENTS = AGENTS;
+function getAgentByFlag(flag) {
+  return AGENTS.find((agent) => agent.flag === flag);
+}
+function getSupportedAgentsMessage() {
+  return `Currently supported agents: ${AGENTS.map((a) => a.name).join(", ")}`;
+}
+
+// src/commands/add.ts
+import chalk2 from "chalk";
+import ora from "ora";
+
+// src/core/config-manager.ts
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".sun");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  defaultAgents: [],
+  firstRunComplete: false
+};
+async function ensureConfigDir() {
+  await fs.ensureDir(CONFIG_DIR);
+}
+async function loadConfig() {
+  try {
+    await ensureConfigDir();
+    if (await fs.pathExists(CONFIG_FILE)) {
+      const content = await fs.readFile(CONFIG_FILE, "utf-8");
+      return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+    }
+  } catch {
+  }
+  return { ...DEFAULT_CONFIG };
+}
+async function saveConfig(config) {
+  await ensureConfigDir();
+  await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+async function isFirstRun() {
+  const config = await loadConfig();
+  return !config.firstRunComplete;
+}
+async function getDefaultAgents() {
+  const config = await loadConfig();
+  return config.defaultAgents;
+}
+async function setDefaultAgents(agents) {
+  const config = await loadConfig();
+  config.defaultAgents = agents;
+  config.firstRunComplete = true;
+  await saveConfig(config);
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+// src/core/agent-detect.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+import os2 from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var AGENT_FOLDER_NAMES = new Set(SUPPORTED_AGENTS.map((a) => a.folderName));
+async function detectAgentsInDirectory(directory, isGlobal) {
+  const detected = [];
+  for (const agent of SUPPORTED_AGENTS) {
+    const agentPath = path2.join(directory, agent.folderName);
+    if (await fs2.pathExists(agentPath)) {
+      detected.push({
+        agent,
+        path: agentPath,
+        isGlobal
+      });
+    }
+  }
+  return detected;
+}
+async function detectLocalAgents() {
+  return detectAgentsInDirectory(process.cwd(), false);
+}
+async function detectGlobalAgents() {
+  return detectAgentsInDirectory(os2.homedir(), true);
+}
+async function detectAllAgents() {
+  const [local, global] = await Promise.all([
+    detectLocalAgents(),
+    detectGlobalAgents()
+  ]);
+  return [...local, ...global];
+}
+
+// src/core/skill-install.ts
+import fs6 from "fs-extra";
+import path6 from "path";
+import os4 from "os";
+import { execFileSync } from "child_process";
+import AdmZip from "adm-zip";
+
+// src/core/skill-source.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+
+// src/lib/supabase.ts
+var API_URL = "https://vfbndmrgggrhnlrileqv.supabase.co/functions/v1/skills";
+async function fetchSkills() {
+  const res = await fetch(`${API_URL}/list`);
+  if (!res.ok) throw new Error(`Failed to fetch skills: ${res.statusText}`);
+  return res.json();
+}
+async function trackDownload(skillName) {
+  try {
+    await fetch(`${API_URL}/track`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ skill_name: skillName })
+    });
+  } catch {
+  }
+}
+
+// src/utils/registry.ts
+var STORAGE_URL = "https://vfbndmrgggrhnlrileqv.supabase.co/storage/v1/object/public/skill-zips";
+var skillsCache = null;
+async function getSkillsFromRegistry() {
+  if (!skillsCache) {
+    skillsCache = await fetchSkills();
+  }
+  return skillsCache;
+}
+async function getSkillByName(name) {
+  const skills = await getSkillsFromRegistry();
+  return skills.find((skill) => skill.name === name);
+}
+async function isShortcut(skill) {
+  return await getSkillByName(skill) !== void 0;
+}
+async function getShortcutUrl(skill) {
+  return (await getSkillByName(skill))?.degit_path;
+}
+async function getShortcutZipUrl(skill) {
+  const zipPath = (await getSkillByName(skill))?.zip_path;
+  return zipPath ? `${STORAGE_URL}/${zipPath}` : void 0;
+}
+
+// src/core/skill-source.ts
+function isGithubUrl(input) {
+  return input.includes("github.com");
+}
+function normalizeGithubUrl(url) {
+  let location = url.trim();
+  location = location.replace(/^git\+/, "");
+  const urlString = /^[a-z]+:\/\//i.test(location) ? location : `https://${location}`;
+  let pathname = "";
+  try {
+    const parsed = new URL(urlString);
+    pathname = parsed.pathname;
+  } catch {
+    pathname = urlString.replace(/^https?:\/\//, "");
+  }
+  pathname = pathname.replace(/^\/+/, "");
+  const parts = pathname.split("/").filter(Boolean);
+  if (parts[0] === "github.com") {
+    parts.shift();
+  }
+  if (parts.length < 2) {
+    return pathname;
+  }
+  const user = parts[0];
+  const repo = parts[1].replace(/\.git$/, "");
+  const kind = parts[2];
+  if (kind === "tree" || kind === "blob" || kind === "raw") {
+    const branch = parts[3] || "";
+    let subpath = parts.slice(4).join("/");
+    if (kind !== "tree" && subpath) {
+      const subparts = subpath.split("/");
+      subparts.pop();
+      subpath = subparts.join("/");
+    }
+    if (branch) {
+      return subpath ? `${user}/${repo}/${subpath}#${branch}` : `${user}/${repo}#${branch}`;
+    }
+  }
+  const extraPath = parts.slice(2).join("/");
+  return extraPath ? `${user}/${repo}/${extraPath}` : `${user}/${repo}`;
+}
+function isLocalPath(input) {
+  if (input.startsWith("./") || input.startsWith("../") || input.startsWith("~/") || input.startsWith("/")) {
+    return true;
+  }
+  const resolved = path3.resolve(input);
+  return fs3.pathExistsSync(resolved);
+}
+async function resolveSkillSource(input) {
+  if (await isShortcut(input)) {
+    const degitPath = await getShortcutUrl(input);
+    if (!degitPath) {
+      throw new Error(`Skill "${input}" found in registry but has no degit_path`);
+    }
+    return {
+      type: "shortcut",
+      location: degitPath,
+      originalInput: input
+    };
+  }
+  if (isGithubUrl(input)) {
+    return {
+      type: "github",
+      location: normalizeGithubUrl(input),
+      originalInput: input
+    };
+  }
+  if (isLocalPath(input)) {
+    let location = input;
+    if (location.startsWith("~/")) {
+      location = path3.join(process.env.HOME || "", location.slice(2));
+    }
+    location = path3.resolve(location);
+    return {
+      type: "local",
+      location,
+      originalInput: input
+    };
+  }
+  throw new Error(`Skill not found: "${input}". Expected a shortcut name, GitHub URL, or local path.`);
+}
+
+// src/core/skill-info.ts
+import fs5 from "fs-extra";
+import path5 from "path";
+import os3 from "os";
+
+// src/core/skill-hash.ts
+import crypto from "crypto";
+import fs4 from "fs-extra";
+import path4 from "path";
+async function getAllFiles(dir) {
+  const files = [];
+  async function walk(currentDir) {
+    const entries = await fs4.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path4.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return files.sort();
+}
+async function computeContentHash(skillPath) {
+  const files = await getAllFiles(skillPath);
+  if (files.length === 0) {
+    return crypto.createHash("sha256").update("").digest("hex").slice(0, 12);
+  }
+  const hash = crypto.createHash("sha256");
+  for (const file of files) {
+    const relativePath = path4.relative(skillPath, file);
+    hash.update(relativePath);
+    const content = await fs4.readFile(file);
+    hash.update(content);
+  }
+  return hash.digest("hex").slice(0, 12);
+}
+
+// src/core/skill-info.ts
+function parseFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+  const lines = frontmatterMatch[1].split("\n");
+  let name = "";
+  let description = "";
+  let license;
+  let compatibility;
+  let allowedTools;
+  const metadata = {};
+  let inMetadata = false;
+  for (const line of lines) {
+    if (line.match(/^metadata:\s*$/)) {
+      inMetadata = true;
+      continue;
+    }
+    if (inMetadata && line.match(/^\S/)) {
+      inMetadata = false;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (inMetadata) {
+        metadata[key] = value;
+      } else {
+        switch (key) {
+          case "name":
+            name = value;
+            break;
+          case "description":
+            description = value;
+            break;
+          case "license":
+            license = value;
+            break;
+          case "compatibility":
+            compatibility = value;
+            break;
+          case "allowed-tools":
+            allowedTools = value;
+            break;
+        }
+      }
+    }
+  }
+  if (!name || !description) {
+    return null;
+  }
+  return {
+    name,
+    description,
+    license,
+    compatibility,
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
+    allowedTools
+  };
+}
+async function isValidSkillDirectory(dirPath) {
+  const skillMdPath = path5.join(dirPath, "SKILL.md");
+  if (!await fs5.pathExists(skillMdPath)) {
+    return false;
+  }
+  try {
+    const content = await fs5.readFile(skillMdPath, "utf-8");
+    const metadata = parseFrontmatter(content);
+    return metadata !== null;
+  } catch {
+    return false;
+  }
+}
+async function findSkillDirectories(searchPath) {
+  const skills = [];
+  async function searchRecursively(dir) {
+    try {
+      const entries = await fs5.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path5.join(dir, entry.name);
+        if (entry.isFile() && entry.name === "SKILL.md") {
+          if (await isValidSkillDirectory(dir)) {
+            skills.push(dir);
+          }
+        } else if (entry.isDirectory() && !entry.name.startsWith(".git")) {
+          await searchRecursively(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  await searchRecursively(searchPath);
+  return skills;
+}
+async function readSkillMetadata(skillPath) {
+  const skillMdPath = path5.join(skillPath, "SKILL.md");
+  try {
+    const content = await fs5.readFile(skillMdPath, "utf-8");
+    return parseFrontmatter(content);
+  } catch {
+    return null;
+  }
+}
+async function getSkillName(skillPath) {
+  const metadata = await readSkillMetadata(skillPath);
+  return metadata?.name || null;
+}
+async function findSkillInstallations(skillName) {
+  const installations = [];
+  const locations = [
+    { base: process.cwd(), isGlobal: false },
+    { base: os3.homedir(), isGlobal: true }
+  ];
+  for (const { base, isGlobal } of locations) {
+    for (const agent of SUPPORTED_AGENTS) {
+      const skillPath = path5.join(base, agent.folderName, "skills", skillName);
+      if (await fs5.pathExists(skillPath)) {
+        const metadata = await readSkillMetadata(skillPath);
+        if (metadata) {
+          const contentHash = await computeContentHash(skillPath);
+          installations.push({
+            agent: agent.flag,
+            path: skillPath,
+            isGlobal,
+            metadata,
+            contentHash
+          });
+        }
+      }
+    }
+  }
+  return installations;
+}
+async function listSkillsForAgent(agentFolderName, isGlobal) {
+  const base = isGlobal ? os3.homedir() : process.cwd();
+  const skillsDir = path5.join(base, agentFolderName, "skills");
+  if (!await fs5.pathExists(skillsDir)) {
+    return [];
+  }
+  const entries = await fs5.readdir(skillsDir, { withFileTypes: true });
+  const skills = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillPath = path5.join(skillsDir, entry.name);
+      const skillName = await getSkillName(skillPath);
+      if (skillName) {
+        skills.push(skillName);
+      }
+    }
+  }
+  return skills;
+}
+
+// src/core/skill-install.ts
+function getSkillInstallPath(skillName, agentFlag, isGlobal) {
+  const agent = getAgentByFlag(agentFlag);
+  if (!agent) {
+    throw new Error(`Unknown agent: ${agentFlag}`);
+  }
+  const base = isGlobal ? os4.homedir() : process.cwd();
+  return path6.join(base, agent.folderName, "skills", skillName);
+}
+async function installSkillDirectory(skillDir, agentFlag, isGlobal, confirmOverride) {
+  const metadata = await readSkillMetadata(skillDir);
+  if (!metadata) {
+    throw new Error(`Invalid skill at "${skillDir}": SKILL.md must have name and description in frontmatter`);
+  }
+  const dest = getSkillInstallPath(metadata.name, agentFlag, isGlobal);
+  if (await fs6.pathExists(dest)) {
+    if (confirmOverride) {
+      const shouldOverwrite = await confirmOverride({
+        skillName: metadata.name,
+        agentFlag,
+        isGlobal,
+        destPath: dest
+      });
+      if (!shouldOverwrite) {
+        return null;
+      }
+    }
+  }
+  await fs6.ensureDir(path6.dirname(dest));
+  await fs6.copy(skillDir, dest, { overwrite: true });
+  return metadata.name;
+}
+async function installFromLocal(source, agentFlag, isGlobal, confirmOverride) {
+  const skillDirs = await findSkillDirectories(source.location);
+  if (skillDirs.length === 0) {
+    throw new Error(`No skills found in "${source.location}". A skill must contain a SKILL.md file.`);
+  }
+  const installedSkills = [];
+  for (const skillDir of skillDirs) {
+    const skillName = await installSkillDirectory(skillDir, agentFlag, isGlobal, confirmOverride);
+    if (skillName) {
+      installedSkills.push(skillName);
+    }
+  }
+  return installedSkills;
+}
+async function installFromZip(zipUrl, source, agentFlag, isGlobal, confirmOverride) {
+  const tempDir = path6.join(os4.tmpdir(), `sun-install-${Date.now()}`);
+  try {
+    const response = await fetch(zipUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to download: ${response.statusText}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const zip = new AdmZip(buffer);
+    await fs6.ensureDir(tempDir);
+    zip.extractAllTo(tempDir, true);
+    const entries = await fs6.readdir(tempDir);
+    const extractedDir = entries.length === 1 && (await fs6.stat(path6.join(tempDir, entries[0]))).isDirectory() ? path6.join(tempDir, entries[0]) : tempDir;
+    const skillDirs = await findSkillDirectories(extractedDir);
+    if (skillDirs.length === 0) {
+      throw new Error(`No skills found in "${source.originalInput}". A skill must contain a SKILL.md file.`);
+    }
+    const installedSkills = [];
+    for (const skillDir of skillDirs) {
+      const skillName = await installSkillDirectory(skillDir, agentFlag, isGlobal, confirmOverride);
+      if (skillName) {
+        installedSkills.push(skillName);
+      }
+    }
+    return installedSkills;
+  } finally {
+    await fs6.remove(tempDir).catch(() => {
+    });
+  }
+}
+async function installFromGithub(source, agentFlag, isGlobal, confirmOverride) {
+  const tempDir = path6.join(os4.tmpdir(), `sun-install-${Date.now()}`);
+  try {
+    await fs6.ensureDir(tempDir);
+    try {
+      execFileSync("npx", ["degit", source.location, tempDir], {
+        stdio: "pipe"
+      });
+    } catch (error) {
+      const err = error;
+      const stderr = err.stderr?.toString() || err.message;
+      throw new Error(`Failed to download from GitHub: ${stderr}`);
+    }
+    const skillDirs = await findSkillDirectories(tempDir);
+    if (skillDirs.length === 0) {
+      throw new Error(`No skills found in "${source.originalInput}". A skill must contain a SKILL.md file.`);
+    }
+    const installedSkills = [];
+    for (const skillDir of skillDirs) {
+      const skillName = await installSkillDirectory(skillDir, agentFlag, isGlobal, confirmOverride);
+      if (skillName) {
+        installedSkills.push(skillName);
+      }
+    }
+    return installedSkills;
+  } finally {
+    await fs6.remove(tempDir).catch(() => {
+    });
+  }
+}
+async function installSkill(skillInput, agentFlag, isGlobal, confirmOverride) {
+  const source = await resolveSkillSource(skillInput);
+  let skillNames;
+  switch (source.type) {
+    case "local":
+      skillNames = await installFromLocal(source, agentFlag, isGlobal, confirmOverride);
+      break;
+    case "shortcut": {
+      const zipUrl = await getShortcutZipUrl(source.originalInput);
+      if (zipUrl) {
+        skillNames = await installFromZip(zipUrl, source, agentFlag, isGlobal, confirmOverride);
+      } else {
+        skillNames = await installFromGithub(source, agentFlag, isGlobal, confirmOverride);
+      }
+      break;
+    }
+    case "github":
+      skillNames = await installFromGithub(source, agentFlag, isGlobal, confirmOverride);
+      break;
+    default:
+      throw new Error(`Unknown source type: ${source.type}`);
+  }
+  if (source.type === "shortcut") {
+    await trackDownload(source.originalInput);
+  }
+  return { skillNames, source };
+}
+async function removeSkill(skillName, agentFlag, isGlobal) {
+  const dest = getSkillInstallPath(skillName, agentFlag, isGlobal);
+  if (await fs6.pathExists(dest)) {
+    await fs6.remove(dest);
+    return true;
+  }
+  return false;
+}
+
+// src/utils/prompts.ts
+import chalk from "chalk";
+import { confirm } from "@inquirer/prompts";
+
+// src/utils/checkbox-extended.ts
+import {
+  Separator,
+  ValidationError,
+  createPrompt,
+  isDownKey,
+  isEnterKey,
+  isNumberKey,
+  isSpaceKey,
+  isTabKey,
+  isUpKey,
+  makeTheme,
+  useKeypress,
+  useMemo,
+  usePagination,
+  usePrefix,
+  useState
+} from "@inquirer/core";
+import { cursorHide } from "@inquirer/ansi";
+import figures from "@inquirer/figures";
+import { styleText } from "util";
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function isChecked(item) {
+  return isSelectable(item) && item.checked;
+}
+function toggle(item) {
+  return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+function check(checked) {
+  return function(item) {
+    return isSelectable(item) ? { ...item, checked } : item;
+  };
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice)) return choice;
+    if (typeof choice === "string") {
+      return {
+        value: choice,
+        name: choice,
+        short: choice,
+        checkedName: choice,
+        disabled: false,
+        checked: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      checkedName: choice.checkedName ?? name,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false
+    };
+    if (choice.description) normalizedChoice.description = choice.description;
+    return normalizedChoice;
+  });
+}
+function nextSelectableIndex(items, from, direction) {
+  let next = from;
+  do {
+    next = (next + direction + items.length) % items.length;
+  } while (!isSelectable(items[next]));
+  return next;
+}
+var checkboxTheme = {
+  icon: {
+    // Slightly larger/more visible rings by default vs the upstream checkbox prompt.
+    checked: styleText("green", figures.circleFilled),
+    unchecked: figures.circleDouble,
+    cursor: figures.pointer
+  },
+  style: {
+    disabledChoice: (text) => styleText("dim", `- ${text}`),
+    renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+    description: (text) => styleText("cyan", text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText("bold", key)} ${styleText("dim", action)}`).join(styleText("dim", " \u2022 "))
+  },
+  keybindings: []
+};
+var checkboxExtended = createPrompt((config, done) => {
+  const { pageSize = 7, loop = true, required, validate = () => true } = config;
+  const shortcuts = { all: "a", invert: "i", ...config.shortcuts };
+  const theme = makeTheme(checkboxTheme, config.theme);
+  const { keybindings } = theme;
+  const [status, setStatus] = useState("idle");
+  const prefix = usePrefix({ status, theme });
+  const [items, setItems] = useState(normalizeChoices(config.choices));
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isSelectable);
+    const last = items.findLastIndex(isSelectable);
+    if (first === -1) {
+      throw new ValidationError("[checkbox prompt] No selectable choices. All choices are disabled.");
+    }
+    return { first, last };
+  }, [items]);
+  const [active, setActive] = useState(bounds.first);
+  const [errorMsg, setError] = useState();
+  useKeypress(async (key) => {
+    if (isEnterKey(key)) {
+      const selection = items.filter(isChecked);
+      const isValid = await validate([...selection]);
+      if (required && !items.some(isChecked)) {
+        setError("At least one choice must be selected");
+      } else if (isValid === true) {
+        setStatus("done");
+        done(selection.map((choice) => choice.value));
+      } else {
+        setError(isValid || "You must select a valid value");
+      }
+      return;
+    }
+    if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+      if (loop || isUpKey(key, keybindings) && active !== bounds.first || isDownKey(key, keybindings) && active !== bounds.last) {
+        const direction = isUpKey(key, keybindings) ? -1 : 1;
+        setActive(nextSelectableIndex(items, active, direction));
+      }
+      return;
+    }
+    const isLeftRight = key.name === "left" || key.name === "right";
+    if (isSpaceKey(key) || isLeftRight) {
+      setError(void 0);
+      setItems(items.map((choice, i) => i === active ? toggle(choice) : choice));
+      return;
+    }
+    if (isTabKey(key)) {
+      setError(void 0);
+      setItems(items.map((choice, i) => i === active ? toggle(choice) : choice));
+      return;
+    }
+    if (key.name === shortcuts.all) {
+      const selectAll = items.some((choice) => isSelectable(choice) && !choice.checked);
+      setItems(items.map(check(selectAll)));
+      return;
+    }
+    if (key.name === shortcuts.invert) {
+      setItems(items.map(toggle));
+      return;
+    }
+    if (isNumberKey(key)) {
+      const selectedIndex = Number(key.name) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item) => {
+        if (Separator.isSeparator(item)) return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const selectedItem = items[position];
+      if (selectedItem && isSelectable(selectedItem)) {
+        setActive(position);
+        setItems(items.map((choice, i) => i === position ? toggle(choice) : choice));
+      }
+    }
+  });
+  const message = theme.style.message(config.message, status);
+  let description;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive }) {
+      if (Separator.isSeparator(item)) return ` ${item.separator}`;
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+        return theme.style.disabledChoice(`${item.name} ${disabledLabel}`);
+      }
+      if (isActive) description = item.description;
+      const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+      const name = item.checked ? item.checkedName : item.name;
+      const color = isActive ? theme.style.highlight : (x) => x;
+      const cursor = isActive ? theme.icon.cursor : " ";
+      return color(`${cursor}${checkbox} ${name}`);
+    },
+    pageSize,
+    loop
+  });
+  if (status === "done") {
+    const selection = items.filter(isChecked);
+    const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+    return [prefix, message, answer].filter(Boolean).join(" ");
+  }
+  const keys = [
+    ["\u2191\u2193", "navigate"],
+    ["space/tab/\u2190\u2192", "toggle"]
+  ];
+  if (shortcuts.all) keys.push([shortcuts.all, "all"]);
+  if (shortcuts.invert) keys.push([shortcuts.invert, "invert"]);
+  keys.push(["\u23CE", "submit"]);
+  const helpLine = theme.style.keysHelpTip(keys);
+  const lines = [
+    [prefix, message].filter(Boolean).join(" "),
+    page,
+    " ",
+    description ? theme.style.description(description) : "",
+    errorMsg ? theme.style.error(errorMsg) : "",
+    helpLine
+  ].filter(Boolean).join("\n").trimEnd();
+  return `${lines}${cursorHide}`;
+});
+
+// src/utils/prompts.ts
+async function promptAgentSelection(currentDefaults = []) {
+  const isFirstRun2 = currentDefaults.length === 0;
+  const choices = SUPPORTED_AGENTS.map((agent) => ({
+    name: `${agent.name} (~/${agent.folderName}/ and ./${agent.folderName}/)`,
+    value: agent.flag,
+    // First run: select ALL agents
+    // Otherwise: only select if it was in previous defaults
+    checked: isFirstRun2 ? true : currentDefaults.includes(agent.flag)
+  }));
+  const selectedAgents = await checkboxExtended({
+    message: "Select default agents:",
+    choices,
+    required: true,
+    theme: {
+      icon: {
+        // Make the selection marker stand out a bit more.
+        checked: chalk.green("\u25C9"),
+        unchecked: chalk.white("\u25CE"),
+        cursor: chalk.white("\u276F")
+      },
+      style: {
+        // Keep active line readable (esp. on dark terminals) and avoid “cyan highlight”.
+        highlight: (text) => chalk.bold.white(text)
+      }
+    }
+  });
+  return selectedAgents;
+}
+async function promptSkillOverride(params) {
+  const agent = getAgentByFlag(params.agentFlag);
+  const agentLabel = agent ? agent.name : params.agentFlag;
+  const locationLabel = params.isGlobal ? "global" : "local";
+  return confirm({
+    message: `Skill "${params.skillName}" already exists in ${agentLabel} (${locationLabel}) at ${params.destPath}. Override?`,
+    default: false
+  });
+}
+
+// src/utils/tree.ts
+import fs7 from "fs-extra";
+import path7 from "path";
+var DEFAULT_IGNORES = /* @__PURE__ */ new Set([".git", ".DS_Store"]);
+function sortEntries(entries) {
+  return entries.slice().sort((a, b) => {
+    const aIsDir = a.isDirectory();
+    const bIsDir = b.isDirectory();
+    if (aIsDir !== bIsDir) {
+      return aIsDir ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+}
+async function walkTree(dir, prefix, depth, maxDepth) {
+  if (maxDepth !== void 0 && depth > maxDepth) {
+    return [];
+  }
+  let entries;
+  try {
+    entries = await fs7.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const visibleEntries = sortEntries(entries).filter((entry) => !DEFAULT_IGNORES.has(entry.name));
+  const lines = [];
+  for (let i = 0; i < visibleEntries.length; i++) {
+    const entry = visibleEntries[i];
+    const isLast = i === visibleEntries.length - 1;
+    const connector = isLast ? "\\-- " : "|-- ";
+    const line = `${prefix}${connector}${entry.name}`;
+    lines.push(line);
+    if (entry.isDirectory()) {
+      const nextPrefix = `${prefix}${isLast ? "    " : "|   "}`;
+      const childLines = await walkTree(path7.join(dir, entry.name), nextPrefix, depth + 1, maxDepth);
+      lines.push(...childLines);
+    }
+  }
+  return lines;
+}
+async function formatDirectoryTree(rootPath, maxDepth) {
+  const rootName = path7.basename(rootPath);
+  const lines = [rootName];
+  const childLines = await walkTree(rootPath, "", 1, maxDepth);
+  lines.push(...childLines);
+  return lines.join("\n");
+}
+function indentLines(text, indent) {
+  return text.split("\n").map((line) => `${indent}${line}`).join("\n");
+}
+
+// src/commands/add.ts
+async function resolveTargetAgents(flags) {
+  const forceGlobal = flags.global ?? false;
+  const explicitAgents = [];
+  for (const agent of SUPPORTED_AGENTS) {
+    if (flags[agent.flag]) {
+      explicitAgents.push(agent.flag);
+    }
+  }
+  let targetAgents;
+  if (explicitAgents.length > 0) {
+    targetAgents = explicitAgents;
+  } else if (await isFirstRun()) {
+    const selectedAgents = await promptAgentSelection();
+    await setDefaultAgents(selectedAgents);
+    targetAgents = selectedAgents;
+  } else {
+    const defaultAgents = await getDefaultAgents();
+    if (defaultAgents.length === 0) {
+      throw new Error('No default agents configured. Run "sun config" to set up your agents.');
+    }
+    targetAgents = defaultAgents;
+  }
+  if (forceGlobal) {
+    return { agents: targetAgents, isGlobal: true };
+  }
+  const localAgents = await detectLocalAgents();
+  const localAgentFlags = new Set(localAgents.map((a) => a.agent.flag));
+  const hasLocalFolders = targetAgents.some((agentFlag) => localAgentFlags.has(agentFlag));
+  const isGlobal = !hasLocalFolders;
+  return { agents: targetAgents, isGlobal };
+}
+function formatList(items) {
+  if (items.length === 0) {
+    return "";
+  }
+  if (items.length === 1) {
+    return items[0];
+  }
+  if (items.length === 2) {
+    return `${items[0]} or ${items[1]}`;
+  }
+  return `${items.slice(0, -1).join(", ")}, or ${items[items.length - 1]}`;
+}
+async function addCommand(skills, flags) {
+  const { agents, isGlobal } = await resolveTargetAgents(flags);
+  const hasExplicitAgentFlags = SUPPORTED_AGENTS.some((agent) => flags[agent.flag]);
+  const results = [];
+  for (const skill of skills) {
+    const spinner = ora(`Adding ${skill}...`).start();
+    const confirmOverride = async (params) => {
+      if (spinner.isSpinning) {
+        spinner.stop();
+      }
+      return promptSkillOverride(params);
+    };
+    const result = {
+      skill,
+      installedNames: [],
+      agents: [],
+      isGlobal
+    };
+    try {
+      for (const agentFlag of agents) {
+        const { skillNames } = await installSkill(skill, agentFlag, isGlobal, confirmOverride);
+        if (skillNames.length > 0) {
+          result.installedNames = [.../* @__PURE__ */ new Set([...result.installedNames, ...skillNames])];
+          result.agents.push(getAgentByFlag(agentFlag).name);
+        }
+      }
+      if (result.installedNames.length === 0) {
+        spinner.info(`Skipped ${skill}`);
+      } else {
+        spinner.succeed(`Added ${result.installedNames.join(", ")}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.error = message;
+      spinner.fail(`Failed to add ${skill}: ${message}`);
+    }
+    results.push(result);
+  }
+  const successful = results.filter((r) => !r.error && r.installedNames.length > 0);
+  if (successful.length > 0) {
+    const allSkills = [...new Set(successful.flatMap((r) => r.installedNames))];
+    const agentFolders = [...new Set(successful.flatMap((r) => r.agents))];
+    const primaryAgent = agents[0];
+    if (primaryAgent) {
+      for (const result of successful) {
+        const skillNames = [...new Set(result.installedNames)];
+        for (const skillName of skillNames) {
+          const treePath = getSkillInstallPath(skillName, primaryAgent, result.isGlobal);
+          const tree = await formatDirectoryTree(treePath);
+          console.log();
+          console.log(chalk2.cyan(`Skill folder for ${skillName}:`));
+          console.log(indentLines(tree, "  "));
+        }
+      }
+    }
+    console.log();
+    const location = isGlobal ? "(global)" : "(local)";
+    console.log(chalk2.green(`Added ${allSkills.join(", ")} to ${agentFolders.join(" and ")} ${chalk2.gray(location)}`));
+    const promptAgents = hasExplicitAgentFlags ? agents : await getDefaultAgents();
+    const commandHints = promptAgents.map((command) => `\`${command}\``);
+    const plural = allSkills.length > 1 ? "skills" : "skill";
+    console.log(chalk2.cyan(`Next: run ${formatList(commandHints)} and ask it to use the downloaded ${plural}`));
+  }
+}
+
+// src/commands/remove.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+async function resolveTargetAgents2(flags) {
+  const forceGlobal = flags.global ?? false;
+  const explicitAgents = [];
+  for (const agent of SUPPORTED_AGENTS) {
+    if (flags[agent.flag]) {
+      explicitAgents.push(agent.flag);
+    }
+  }
+  let targetAgents;
+  if (explicitAgents.length > 0) {
+    targetAgents = explicitAgents;
+  } else {
+    const defaultAgents = await getDefaultAgents();
+    if (defaultAgents.length === 0) {
+      throw new Error('No default agents configured. Run "sun add" first or use --claude/--codex/--gemini flags.');
+    }
+    targetAgents = defaultAgents;
+  }
+  if (forceGlobal) {
+    return { agents: targetAgents, isGlobal: true };
+  }
+  const localAgents = await detectLocalAgents();
+  const localAgentFlags = new Set(localAgents.map((a) => a.agent.flag));
+  const hasLocalFolders = targetAgents.some((agentFlag) => localAgentFlags.has(agentFlag));
+  const isGlobal = !hasLocalFolders;
+  return { agents: targetAgents, isGlobal };
+}
+async function removeCommand(skills, flags) {
+  let agents;
+  let isGlobal;
+  try {
+    const resolved = await resolveTargetAgents2(flags);
+    agents = resolved.agents;
+    isGlobal = resolved.isGlobal;
+  } catch (error) {
+    console.error(chalk3.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+  const results = [];
+  for (const skill of skills) {
+    const spinner = ora2(`Removing ${skill}...`).start();
+    const result = {
+      skill,
+      removedFrom: [],
+      notFoundIn: [],
+      isGlobal
+    };
+    try {
+      for (const agentFlag of agents) {
+        const removed = await removeSkill(skill, agentFlag, isGlobal);
+        const agentName = getAgentByFlag(agentFlag).name;
+        if (removed) {
+          result.removedFrom.push(agentName);
+        } else {
+          result.notFoundIn.push(agentName);
+        }
+      }
+      if (result.removedFrom.length > 0) {
+        spinner.succeed(`Removed ${skill} from ${result.removedFrom.join(" and ")}`);
+      } else {
+        const pathPrefix = isGlobal ? "~/" : "./";
+        const checkedPaths = agents.map((a) => `${pathPrefix}${getAgentByFlag(a).folderName}/`);
+        spinner.warn(`${skill} not found in configured agents (${checkedPaths.join(", ")})`);
+      }
+      if (result.notFoundIn.length > 0 && result.removedFrom.length > 0) {
+        console.log(chalk3.gray(`  (not found in: ${result.notFoundIn.join(", ")})`));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.error = message;
+      spinner.fail(`Failed to remove ${skill}: ${message}`);
+    }
+    results.push(result);
+  }
+  if (skills.length > 1) {
+    const totalRemoved = results.filter((r) => r.removedFrom.length > 0).length;
+    const totalFailed = results.filter((r) => r.error || r.removedFrom.length === 0).length;
+    console.log();
+    if (totalRemoved > 0) {
+      console.log(chalk3.green(`Removed ${totalRemoved} skill(s)`));
+    }
+    if (totalFailed > 0) {
+      console.log(chalk3.yellow(`${totalFailed} skill(s) not found or failed`));
+    }
+  }
+}
+
+// src/commands/list.ts
+import chalk4 from "chalk";
+async function listCommand() {
+  const allAgentSkills = [];
+  for (const agent of SUPPORTED_AGENTS) {
+    const localSkills = await listSkillsForAgent(agent.folderName, false);
+    if (localSkills.length > 0) {
+      allAgentSkills.push({
+        agentName: agent.name,
+        folderName: agent.folderName,
+        isGlobal: false,
+        skills: localSkills
+      });
+    }
+    const globalSkills = await listSkillsForAgent(agent.folderName, true);
+    if (globalSkills.length > 0) {
+      allAgentSkills.push({
+        agentName: agent.name,
+        folderName: agent.folderName,
+        isGlobal: true,
+        skills: globalSkills
+      });
+    }
+  }
+  if (allAgentSkills.length === 0) {
+    console.log(chalk4.yellow("No skills installed."));
+    console.log();
+    console.log(chalk4.gray(getSupportedAgentsMessage()));
+    console.log(chalk4.gray('Browse curated skills with "sun list"'));
+    console.log(chalk4.gray('You can add from the library, GitHub URLs, or local paths with "sun add <skill>"'));
+    return;
+  }
+  for (const agentSkills of allAgentSkills) {
+    const location = agentSkills.isGlobal ? `global ~/${agentSkills.folderName}/` : `${agentSkills.folderName}/`;
+    console.log(chalk4.cyan(`${agentSkills.agentName} (${location}):`));
+    for (const skill of agentSkills.skills) {
+      console.log(`  - ${skill}`);
+    }
+    console.log();
+  }
+  console.log(chalk4.gray(getSupportedAgentsMessage()));
+  console.log(chalk4.gray('Browse curated skills with "sun list"'));
+  console.log(chalk4.gray('Add from the library, GitHub URLs, or local paths with "sun add <skill>"'));
+  console.log(chalk4.gray('Remove with "sun remove <skill>"'));
+}
+
+// src/commands/list-registry.ts
+import chalk5 from "chalk";
+async function listRegistryCommand() {
+  const skills = await getSkillsFromRegistry();
+  if (skills.length === 0) {
+    console.log(chalk5.yellow("No skills available in the Sundial library."));
+    console.log(chalk5.gray("You can still add from GitHub URLs or local paths."));
+    console.log(chalk5.gray("Example: sun add github.com/user/skill or sun add ./my-skill"));
+    return;
+  }
+  const sorted = [...skills].sort((a, b) => a.name.localeCompare(b.name));
+  console.log(chalk5.cyan(`Available skills from the Sundial library (${sorted.length}):`));
+  for (const skill of sorted) {
+    const description = skill.description?.trim();
+    const author = skill.author?.trim();
+    const descriptionText = description ? ` - ${description}` : "";
+    const authorText = author ? ` (by ${author})` : "";
+    console.log(`  - ${skill.name}${chalk5.gray(descriptionText + authorText)}`);
+  }
+  console.log();
+  console.log(chalk5.white('Install from the library with "sun add <skill>".'));
+  console.log(chalk5.white("You can also add from GitHub URLs or local paths."));
+}
+
+// src/commands/show.ts
+import chalk7 from "chalk";
+import path9 from "path";
+
+// src/commands/show-dev.ts
+import chalk6 from "chalk";
+import path8 from "path";
+import os5 from "os";
+import fs8 from "fs-extra";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+var FIND_TIMEOUT = 6e4;
+async function listSkillsInDir(skillsDir) {
+  const skills = [];
+  if (!await fs8.pathExists(skillsDir)) {
+    return skills;
+  }
+  const entries = await fs8.readdir(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillPath = path8.join(skillsDir, entry.name);
+      const metadata = await readSkillMetadata(skillPath);
+      if (metadata) {
+        skills.push({
+          name: metadata.name,
+          description: metadata.description
+        });
+      }
+    }
+  }
+  return skills;
+}
+async function showAllAgentFolders() {
+  const homeDir = os5.homedir();
+  const namePatterns = SUPPORTED_AGENTS.map((a) => `-name "${a.folderName}"`).join(" -o ");
+  const findCmd = `find "${homeDir}" -type d \\( ${namePatterns} \\)`;
+  console.log(chalk6.cyan("All Agent Folders"));
+  console.log(chalk6.gray("\u2500".repeat(40)));
+  console.log();
+  let stdout = "";
+  try {
+    const result = await execAsync2(findCmd, { maxBuffer: 10 * 1024 * 1024, timeout: FIND_TIMEOUT });
+    stdout = result.stdout;
+  } catch (err) {
+    if (err.stdout) {
+      stdout = err.stdout;
+    } else {
+      console.log(chalk6.red("Failed to search for agent folders."));
+      console.log(chalk6.gray(String(err)));
+      return;
+    }
+  }
+  const agentPaths = stdout.trim().split("\n").filter(Boolean);
+  if (agentPaths.length === 0) {
+    console.log(chalk6.yellow("No agent folders found."));
+    return;
+  }
+  for (const agentPath of agentPaths) {
+    const folderName = path8.basename(agentPath);
+    const agent = SUPPORTED_AGENTS.find((a) => a.folderName === folderName);
+    if (!agent) continue;
+    console.log(chalk6.white.bold(agent.name));
+    console.log(chalk6.gray(`  ${agentPath}`));
+    const skillsDir = path8.join(agentPath, "skills");
+    const skills = await listSkillsInDir(skillsDir);
+    if (skills.length === 0) {
+      console.log(chalk6.gray("  No skills installed"));
+    } else {
+      console.log(`  Skills (${skills.length}):`);
+      for (const skill of skills) {
+        console.log(`    - ${skill.name} ${chalk6.gray(`- ${skill.description}`)}`);
+      }
+    }
+    console.log();
+  }
+}
+async function showAllAgentSkillsFolders() {
+  const homeDir = os5.homedir();
+  const pathPatterns = SUPPORTED_AGENTS.map((a) => `-path "*/${a.folderName}/skills"`).join(" -o ");
+  const findCmd = `find "${homeDir}" -type d \\( ${pathPatterns} \\)`;
+  console.log(chalk6.cyan("All Agent Skills Folders"));
+  console.log(chalk6.gray("\u2500".repeat(40)));
+  console.log();
+  let stdout = "";
+  try {
+    const result = await execAsync2(findCmd, { maxBuffer: 10 * 1024 * 1024, timeout: FIND_TIMEOUT });
+    stdout = result.stdout;
+  } catch (err) {
+    if (err.stdout) {
+      stdout = err.stdout;
+    } else {
+      console.log(chalk6.red("Failed to search for skills folders."));
+      console.log(chalk6.gray(String(err)));
+      return;
+    }
+  }
+  const skillsDirs = stdout.trim().split("\n").filter(Boolean);
+  if (skillsDirs.length === 0) {
+    console.log(chalk6.yellow("No agent skills folders found."));
+    return;
+  }
+  for (const skillsDir of skillsDirs) {
+    const agentFolder = path8.basename(path8.dirname(skillsDir));
+    const agent = SUPPORTED_AGENTS.find((a) => a.folderName === agentFolder);
+    console.log(chalk6.white.bold(agent?.name ?? agentFolder));
+    console.log(chalk6.gray(`  ${skillsDir}`));
+    const skills = await listSkillsInDir(skillsDir);
+    if (skills.length === 0) {
+      console.log(chalk6.gray("  No skills installed"));
+    } else {
+      console.log(`  Skills (${skills.length}):`);
+      for (const skill of skills) {
+        console.log(`    - ${skill.name} ${chalk6.gray(`- ${skill.description}`)}`);
+      }
+    }
+    console.log();
+  }
+}
+async function showAllSkillFolders() {
+  const homeDir = os5.homedir();
+  const findCmd = `find "${homeDir}" -name "SKILL.md" -type f`;
+  console.log(chalk6.cyan("All Skill Folders"));
+  console.log(chalk6.gray("\u2500".repeat(40)));
+  console.log();
+  let stdout = "";
+  try {
+    const result = await execAsync2(findCmd, { maxBuffer: 10 * 1024 * 1024, timeout: FIND_TIMEOUT });
+    stdout = result.stdout;
+  } catch (err) {
+    if (err.stdout) {
+      stdout = err.stdout;
+    } else {
+      console.log(chalk6.red("Failed to search for SKILL.md files."));
+      console.log(chalk6.gray(String(err)));
+      return;
+    }
+  }
+  const skillMdPaths = stdout.trim().split("\n").filter(Boolean);
+  if (skillMdPaths.length === 0) {
+    console.log(chalk6.yellow("No SKILL.md files found."));
+    return;
+  }
+  let validCount = 0;
+  for (const skillMdPath of skillMdPaths) {
+    const skillDir = path8.dirname(skillMdPath);
+    const metadata = await readSkillMetadata(skillDir);
+    if (metadata && metadata.name && metadata.description) {
+      validCount++;
+      console.log(chalk6.white.bold(metadata.name));
+      console.log(chalk6.gray(`  ${skillDir}`));
+      console.log(`  ${metadata.description}`);
+      console.log();
+    }
+  }
+  if (validCount === 0) {
+    console.log(chalk6.yellow("No valid SKILL.md files found (missing name/description frontmatter)."));
+  }
+}
+
+// src/commands/show.ts
+import fs9 from "fs-extra";
+async function listSkillsInPath(skillsDir) {
+  const skills = [];
+  if (!await fs9.pathExists(skillsDir)) {
+    return skills;
+  }
+  const entries = await fs9.readdir(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillPath = path9.join(skillsDir, entry.name);
+      const metadata = await readSkillMetadata(skillPath);
+      if (metadata) {
+        skills.push({
+          name: metadata.name,
+          description: metadata.description
+        });
+      }
+    }
+  }
+  return skills;
+}
+async function showAllAgents() {
+  const allAgents = await detectAllAgents();
+  const defaultAgents = await getDefaultAgents();
+  const defaultSet = new Set(defaultAgents);
+  const localAgents = await detectLocalAgents();
+  const localAgentFlags = new Set(localAgents.map((a) => a.agent.flag));
+  if (allAgents.length === 0) {
+    console.log(chalk7.yellow("No agent folders found."));
+    console.log(chalk7.gray("Agent folders are directories like .claude/, .codex/, .gemini/"));
+    return;
+  }
+  console.log(chalk7.cyan("Agent Folders & Installed Skills"));
+  console.log(chalk7.gray("\u2500".repeat(40)));
+  console.log();
+  for (const detected of allAgents) {
+    const { agent, path: agentPath, isGlobal } = detected;
+    const locationLabel = isGlobal ? chalk7.gray("(global)") : chalk7.gray("(local)");
+    const isDefault = defaultSet.has(agent.flag);
+    const hasLocalFolder = localAgentFlags.has(agent.flag);
+    const wouldBeAffected = isDefault && (isGlobal ? !hasLocalFolder : true);
+    const marker = wouldBeAffected ? chalk7.green("\u2713") : chalk7.gray("\u25CB");
+    console.log(`${marker} ${chalk7.white.bold(agent.name)} ${locationLabel}`);
+    console.log(chalk7.gray(`  ${agentPath}`));
+    const skillsDir = path9.join(agentPath, "skills");
+    const skills = await listSkillsInPath(skillsDir);
+    if (skills.length === 0) {
+      console.log(chalk7.gray("  No skills installed"));
+    } else {
+      console.log(`  Skills (${skills.length}):`);
+      for (const skill of skills) {
+        console.log(`    - ${skill.name} ${chalk7.gray(`- ${skill.description}`)}`);
+      }
+    }
+    console.log();
+  }
+  console.log(`${chalk7.green("\u2713")} = affected by sun add/remove in this directory`);
+  console.log('Run "sun config" to change selected agents.');
+}
+async function showCommand(skillName) {
+  if (skillName === "all-agent-folders") {
+    await showAllAgentFolders();
+    return;
+  }
+  if (skillName === "all-agent-skills-folders") {
+    await showAllAgentSkillsFolders();
+    return;
+  }
+  if (skillName === "all-skill-folders") {
+    await showAllSkillFolders();
+    return;
+  }
+  if (!skillName) {
+    await showAllAgents();
+    return;
+  }
+  const installations = await findSkillInstallations(skillName);
+  if (installations.length === 0) {
+    console.error(chalk7.yellow(`Skill "${skillName}" is not installed.`));
+    process.exit(1);
+  }
+  const uniqueHashes = new Set(installations.map((i) => i.contentHash));
+  const hasMultipleVersions = uniqueHashes.size > 1;
+  if (hasMultipleVersions) {
+    console.log(chalk7.cyan(`Skill: ${skillName}`));
+    console.log(chalk7.yellow("Warning: Multiple versions detected"));
+    console.log();
+    const byHash = /* @__PURE__ */ new Map();
+    for (const inst of installations) {
+      const existing = byHash.get(inst.contentHash) || [];
+      existing.push(inst);
+      byHash.set(inst.contentHash, existing);
+    }
+    let versionNum = 1;
+    for (const [hash, insts] of byHash) {
+      const firstInst = insts[0];
+      const locations = insts.map((i) => {
+        const agent = getAgentByFlag(i.agent);
+        return i.isGlobal ? `~/${agent.folderName}/` : `${agent.folderName}/`;
+      });
+      console.log(chalk7.white(`Version ${versionNum} (${locations.join(", ")}):`));
+      console.log(`  Description: ${firstInst.metadata.description}`);
+      if (firstInst.metadata.metadata?.author) {
+        console.log(`  Author: ${firstInst.metadata.metadata.author}`);
+      }
+      if (firstInst.metadata.metadata?.version) {
+        console.log(`  Version: ${firstInst.metadata.metadata.version}`);
+      }
+      if (firstInst.metadata.license) {
+        console.log(`  License: ${firstInst.metadata.license}`);
+      }
+      console.log(`  Content hash: ${hash}`);
+      const tree = await formatDirectoryTree(firstInst.path);
+      console.log("  Tree:");
+      console.log(indentLines(tree, "    "));
+      console.log();
+      versionNum++;
+    }
+  } else {
+    const firstInst = installations[0];
+    console.log(chalk7.cyan(`Skill: ${skillName}`));
+    console.log(`Description: ${firstInst.metadata.description}`);
+    if (firstInst.metadata.metadata?.author) {
+      console.log(`Author: ${firstInst.metadata.metadata.author}`);
+    }
+    if (firstInst.metadata.metadata?.version) {
+      console.log(`Version: ${firstInst.metadata.metadata.version}`);
+    }
+    if (firstInst.metadata.license) {
+      console.log(`License: ${firstInst.metadata.license}`);
+    }
+    if (firstInst.metadata.compatibility) {
+      console.log(`Compatibility: ${firstInst.metadata.compatibility}`);
+    }
+    console.log();
+    console.log("Installed in:");
+    for (const inst of installations) {
+      const agent = getAgentByFlag(inst.agent);
+      const base = inst.isGlobal ? `~/${agent.folderName}/` : `${agent.folderName}/`;
+      const location = inst.isGlobal ? "(global)" : "(local)";
+      console.log(`  - ${base}skills/${skillName} ${chalk7.gray(location)}`);
+    }
+    const tree = await formatDirectoryTree(firstInst.path);
+    console.log();
+    console.log("Skill folder:");
+    console.log(indentLines(tree, "  "));
+  }
+}
+
+// src/commands/config.ts
+import chalk8 from "chalk";
+async function configCommand() {
+  const config = await loadConfig();
+  console.log(chalk8.cyan("Sundial CLI Configuration"));
+  console.log(chalk8.gray(`Config file: ${getConfigPath()}`));
+  console.log();
+  if (config.defaultAgents.length > 0) {
+    console.log("Current default agents:");
+    for (const agentFlag of config.defaultAgents) {
+      const agent = SUPPORTED_AGENTS.find((a) => a.flag === agentFlag);
+      if (agent) {
+        console.log(`  - ${agent.name} ${chalk8.gray(`(~/${agent.folderName}/ and ./${agent.folderName}/)`)}`);
+      }
+    }
+    console.log();
+  }
+  const selectedAgents = await promptAgentSelection(config.defaultAgents);
+  await setDefaultAgents(selectedAgents);
+  console.log();
+  console.log(chalk8.green("Configuration saved!"));
+  console.log("New default agents:");
+  for (const agentFlag of selectedAgents) {
+    const agent = SUPPORTED_AGENTS.find((a) => a.flag === agentFlag);
+    if (agent) {
+      console.log(`  - ${agent.name} ${chalk8.gray(`(~/${agent.folderName}/ and ./${agent.folderName}/)`)}`);
+    }
+  }
+}
+
+// src/utils/fuzzy-match.ts
+import fuzzysort from "fuzzysort";
+function findClosestCommand(input) {
+  const results = fuzzysort.go(input, COMMANDS, {
+    threshold: -Infinity
+  });
+  if (results.length === 0) {
+    return null;
+  }
+  const best = results[0];
+  return {
+    command: best.target,
+    score: best.score
+  };
+}
+function suggestCommand(input) {
+  const match = findClosestCommand(input);
+  if (match && match.score > -100) {
+    return match.command;
+  }
+  return null;
+}
+function getValidCommands() {
+  return [...COMMANDS];
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+function isPromptExit(error) {
+  return error instanceof Error && error.name === "ExitPromptError";
+}
+function handleCommandError(error) {
+  if (isPromptExit(error)) {
+    process.exit(130);
+  }
+  console.error(chalk9.red(error instanceof Error ? error.message : String(error)));
+  process.exit(1);
+}
+program.name("sun").description("Sundial CLI - Manage skills for your AI agents").version(version);
+var add = program.command("add <skills...>").description("Add skill(s) to agent configuration(s)").option("--global", "Install to global agent config (~/.claude/, ~/.codex/, etc.)");
+for (const agent of SUPPORTED_AGENTS) {
+  add.option(`--${agent.flag}`, `Install to ${agent.name}`);
+}
+add.action(async (skills, options) => {
+  try {
+    await addCommand(skills, options);
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+var remove = program.command("remove <skills...>").description("Remove skill(s) from agent configuration(s)").option("--global", "Remove from global config");
+for (const agent of SUPPORTED_AGENTS) {
+  remove.option(`--${agent.flag}`, `Remove from ${agent.name}`);
+}
+remove.action(async (skills, options) => {
+  try {
+    await removeCommand(skills, options);
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+program.command("list").description("List available skills from the registry").action(async () => {
+  try {
+    await listRegistryCommand();
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+program.command("installed").alias("list-installed").description("List installed skills for each agent").action(async () => {
+  try {
+    await listCommand();
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+program.command("show [skill]").description("Show all agent folders and packages, or details for a specific skill").action(async (skill) => {
+  try {
+    await showCommand(skill);
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+program.command("config").description("Configure default agents").action(async () => {
+  try {
+    await configCommand();
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+program.on("command:*", (operands) => {
+  const unknownCommand = operands[0];
+  const suggestion = suggestCommand(unknownCommand);
+  console.error(chalk9.red(`Error: Unknown command '${unknownCommand}'`));
+  if (suggestion) {
+    console.error(chalk9.yellow(`Did you mean '${suggestion}'?`));
+  }
+  console.error();
+  console.error(`Valid commands: ${getValidCommands().join(", ")}`);
+  process.exit(1);
+});
+program.parse();
+//# sourceMappingURL=index.js.map