skai 0.0.5 → 0.0.7

package/dist/index.js

@@ -446,7 +446,7 @@ function skillTreeToTreeNodes(node, parentPath = "") {
     result.push({
       id,
       label: s.name,
-      hint: s.skill.description,
+      hint: extractShortSummary(s.skill.description),
       skill: s.skill,
       selected: false
     });
@@ -475,6 +475,28 @@ function matchesSkillFilter(skill, filter) {
   }
   return skill.name.toLowerCase() === filterLower;
 }
+function extractShortSummary(description, maxLength = 50) {
+  if (!description) return "";
+  const triggers = [
+    "This skill should be used",
+    "Triggers on tasks",
+    "Use this skill when",
+    "Apply when"
+  ];
+  let summary = description;
+  for (const trigger of triggers) {
+    const index = summary.indexOf(trigger);
+    if (index > 0) {
+      summary = summary.slice(0, index).trim();
+      break;
+    }
+  }
+  summary = summary.replace(/[.,;:]+$/, "").trim();
+  if (summary.length > maxLength) {
+    summary = summary.slice(0, maxLength - 1).trim() + "\u2026";
+  }
+  return summary;
+}
 
 // src/agents.ts
 import * as fs4 from "fs";
@@ -651,6 +673,146 @@ function installSkillForAgent(skill, agent, options) {
     };
   }
 }
+function uninstallSkill(skillName, agent, options) {
+  const basePath = options.global ? agent.globalPath : path5.join(process.cwd(), agent.projectPath);
+  const sanitizedName = sanitizeName(skillName);
+  const targetPath = path5.join(basePath, sanitizedName);
+  if (!isPathSafe(targetPath, basePath)) {
+    return {
+      skillName,
+      agent,
+      success: false,
+      targetPath,
+      error: `Invalid skill name: ${skillName}`
+    };
+  }
+  if (fs5.existsSync(targetPath)) {
+    try {
+      fs5.rmSync(targetPath, { recursive: true, force: true });
+      return { skillName, agent, success: true, targetPath };
+    } catch (error) {
+      return {
+        skillName,
+        agent,
+        success: false,
+        targetPath,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  return {
+    skillName,
+    agent,
+    success: false,
+    targetPath,
+    error: "Skill not found"
+  };
+}
+function listInstalledSkills(agent, options = {}) {
+  const skills = [];
+  const checkPath = (basePath, scope) => {
+    if (!fs5.existsSync(basePath)) return;
+    try {
+      const entries = fs5.readdirSync(basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          skills.push({
+            name: entry.name,
+            path: path5.join(basePath, entry.name),
+            agent,
+            scope
+          });
+        }
+      }
+    } catch {
+    }
+  };
+  if (!options.global) {
+    const projectPath = path5.join(process.cwd(), agent.projectPath);
+    checkPath(projectPath, "project");
+  }
+  if (!options.projectOnly) {
+    checkPath(agent.globalPath, "global");
+  }
+  return skills;
+}
+function getSkillInstallPath(skillName, agent, options) {
+  const basePath = options.global ? agent.globalPath : path5.join(process.cwd(), agent.projectPath);
+  return path5.join(basePath, sanitizeName(skillName));
+}
+var DISABLED_SUFFIX = ".disabled";
+function listManagedSkills(agent, options = {}) {
+  const skills = [];
+  const checkPath = (basePath, scope) => {
+    if (!fs5.existsSync(basePath)) return;
+    try {
+      const entries = fs5.readdirSync(basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          const isDisabled = entry.name.endsWith(DISABLED_SUFFIX);
+          const name = isDisabled ? entry.name.slice(0, -DISABLED_SUFFIX.length) : entry.name;
+          skills.push({
+            name,
+            path: path5.join(basePath, entry.name),
+            agent,
+            scope,
+            enabled: !isDisabled
+          });
+        }
+      }
+    } catch {
+    }
+  };
+  if (!options.global) {
+    const projectPath = path5.join(process.cwd(), agent.projectPath);
+    checkPath(projectPath, "project");
+  }
+  if (!options.projectOnly) {
+    checkPath(agent.globalPath, "global");
+  }
+  return skills;
+}
+function toggleSkill(skill) {
+  const currentPath = skill.path;
+  const basePath = path5.dirname(currentPath);
+  const currentName = path5.basename(currentPath);
+  let newName;
+  let newEnabled;
+  if (skill.enabled) {
+    newName = currentName + DISABLED_SUFFIX;
+    newEnabled = false;
+  } else {
+    newName = currentName.slice(0, -DISABLED_SUFFIX.length);
+    newEnabled = true;
+  }
+  const newPath = path5.join(basePath, newName);
+  if (!isPathSafe(newPath, basePath)) {
+    return {
+      skillName: skill.name,
+      agent: skill.agent,
+      success: false,
+      enabled: skill.enabled,
+      error: "Invalid skill path"
+    };
+  }
+  try {
+    fs5.renameSync(currentPath, newPath);
+    return {
+      skillName: skill.name,
+      agent: skill.agent,
+      success: true,
+      enabled: newEnabled
+    };
+  } catch (error) {
+    return {
+      skillName: skill.name,
+      agent: skill.agent,
+      success: false,
+      enabled: skill.enabled,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 
 // src/tree-select.ts
 import * as p from "@clack/prompts";
@@ -976,34 +1138,7 @@ var S_BAR_END = import_picocolors.default.gray("\u2514");
 var S_CHECKBOX_ACTIVE = import_picocolors.default.cyan("\u25FB");
 var S_CHECKBOX_SELECTED = import_picocolors.default.green("\u25FC");
 var S_CHECKBOX_INACTIVE = import_picocolors.default.dim("\u25FB");
-var MAX_HINT_LENGTH = 60;
-function truncateHint(hint, maxLen) {
-  if (!hint) return "";
-  if (hint.length <= maxLen) return hint;
-  return hint.slice(0, maxLen - 1) + "\u2026";
-}
-function wrapText(text, maxWidth) {
-  if (!text) return [];
-  const words = text.split(/\s+/);
-  const lines = [];
-  let currentLine = "";
-  for (const word of words) {
-    if (currentLine.length === 0) {
-      currentLine = word;
-    } else if (currentLine.length + 1 + word.length <= maxWidth) {
-      currentLine += " " + word;
-    } else {
-      lines.push(currentLine);
-      currentLine = word;
-    }
-  }
-  if (currentLine) {
-    lines.push(currentLine);
-  }
-  return lines;
-}
-var DESCRIPTION_INDENT = "       ";
-var DESCRIPTION_MAX_WIDTH = 60;
+var MAX_LABEL_WIDTH = 30;
 function buildSearchableOptions(options) {
   return options.map((opt) => ({
     option: opt,
@@ -1191,21 +1326,11 @@ var SearchableMultiSelectPrompt = class extends x {
         } else {
           checkbox = S_CHECKBOX_INACTIVE;
         }
-        const label = this.searchTerm ? highlightMatch(opt.option.label, this.searchTerm) : opt.option.label;
-        const fullHint = opt.option.hint || "";
-        const needsTruncation = fullHint.length > MAX_HINT_LENGTH;
-        const displayHint = needsTruncation ? truncateHint(fullHint, MAX_HINT_LENGTH) : fullHint;
-        const hint = displayHint ? import_picocolors.default.dim(` (${displayHint})`) : "";
-        const line = isActive ? `${checkbox} ${label}${hint}` : `${checkbox} ${import_picocolors.default.dim(opt.option.label)}${import_picocolors.default.dim(hint)}`;
+        const hint = opt.option.hint || "";
+        const paddedLabel = opt.option.label.padEnd(MAX_LABEL_WIDTH);
+        const highlightedPaddedLabel = this.searchTerm ? highlightMatch(paddedLabel, this.searchTerm) : paddedLabel;
+        const line = isActive ? `${checkbox} ${highlightedPaddedLabel} ${import_picocolors.default.dim(hint)}` : `${checkbox} ${import_picocolors.default.dim(paddedLabel)} ${import_picocolors.default.dim(hint)}`;
         lines.push(`${import_picocolors.default.cyan(S_BAR)}  ${line}`);
-        if (isActive && needsTruncation) {
-          const wrappedLines = wrapText(fullHint, DESCRIPTION_MAX_WIDTH);
-          for (const descLine of wrappedLines) {
-            lines.push(
-              `${import_picocolors.default.cyan(S_BAR)}  ${DESCRIPTION_INDENT}${import_picocolors.default.dim(descLine)}`
-            );
-          }
-        }
       }
       if (belowCount > 0) {
         lines.push(
@@ -1454,24 +1579,13 @@ var SearchableGroupMultiSelectPrompt = class extends x {
           } else {
             checkbox = S_CHECKBOX_INACTIVE;
           }
-          const label = this.searchTerm ? highlightMatch(item.option.option.label, this.searchTerm) : item.option.option.label;
-          const fullHint = item.option.option.hint || "";
-          const needsTruncation = fullHint.length > MAX_HINT_LENGTH;
-          const displayHint = needsTruncation ? truncateHint(fullHint, MAX_HINT_LENGTH) : fullHint;
-          const hint = displayHint ? import_picocolors.default.dim(` (${displayHint})`) : "";
+          const hint = item.option.option.hint || "";
           const isLastInGroup = i + 1 >= visibleItems.length || visibleItems[i + 1].type === "group";
           const indent = isLastInGroup ? `${import_picocolors.default.gray("\u2514")} ` : `${import_picocolors.default.gray("\u2502")} `;
-          const line = isActive ? `${indent}${checkbox} ${label}${hint}` : `${indent}${checkbox} ${import_picocolors.default.dim(item.option.option.label)}${import_picocolors.default.dim(hint)}`;
+          const paddedLabel = item.option.option.label.padEnd(MAX_LABEL_WIDTH);
+          const highlightedPaddedLabel = this.searchTerm ? highlightMatch(paddedLabel, this.searchTerm) : paddedLabel;
+          const line = isActive ? `${indent}${checkbox} ${highlightedPaddedLabel} ${import_picocolors.default.dim(hint)}` : `${indent}${checkbox} ${import_picocolors.default.dim(paddedLabel)} ${import_picocolors.default.dim(hint)}`;
           lines.push(`${import_picocolors.default.cyan(S_BAR)}  ${line}`);
-          if (isActive && needsTruncation) {
-            const descIndent = isLastInGroup ? "  " : `${import_picocolors.default.gray("\u2502")} `;
-            const wrappedLines = wrapText(fullHint, DESCRIPTION_MAX_WIDTH);
-            for (const descLine of wrappedLines) {
-              lines.push(
-                `${import_picocolors.default.cyan(S_BAR)}  ${descIndent}${DESCRIPTION_INDENT}${import_picocolors.default.dim(descLine)}`
-              );
-            }
-          }
         }
       }
       if (belowCount > 0) {
@@ -1615,6 +1729,227 @@ async function treeSelect(nodes) {
   return [];
 }
 
+// src/skill-manager.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+var MAX_VISIBLE_ITEMS2 = 12;
+var MAX_NAME_WIDTH = 25;
+var MAX_AGENT_WIDTH = 14;
+var S_STEP_ACTIVE2 = import_picocolors2.default.green("\u25C6");
+var S_STEP_CANCEL2 = import_picocolors2.default.red("\u25A0");
+var S_STEP_SUBMIT2 = import_picocolors2.default.green("\u25C7");
+var S_BAR2 = import_picocolors2.default.gray("\u2502");
+var S_BAR_END2 = import_picocolors2.default.gray("\u2514");
+var S_TOGGLE_ON = import_picocolors2.default.green("\u25CF");
+var S_TOGGLE_OFF = import_picocolors2.default.dim("\u25CB");
+var S_TOGGLE_ACTIVE_ON = import_picocolors2.default.green("\u25C9");
+var S_TOGGLE_ACTIVE_OFF = import_picocolors2.default.cyan("\u25CE");
+function symbol2(state) {
+  switch (state) {
+    case "active":
+      return S_STEP_ACTIVE2;
+    case "cancel":
+      return S_STEP_CANCEL2;
+    case "submit":
+      return S_STEP_SUBMIT2;
+    default:
+      return import_picocolors2.default.cyan("\u25C6");
+  }
+}
+function getSkillKey(skill) {
+  return `${skill.agent.name}:${skill.scope}:${skill.name}`;
+}
+var SkillManagerPrompt = class extends x {
+  state_data;
+  maxItems;
+  constructor(skills) {
+    super(
+      {
+        render: () => this.renderPrompt()
+      },
+      false
+    );
+    this.state_data = {
+      skills,
+      cursor: 0,
+      scrollOffset: 0,
+      changes: /* @__PURE__ */ new Map()
+    };
+    this.maxItems = MAX_VISIBLE_ITEMS2;
+    this.on("cursor", (action) => this.handleCursor(action ?? "up"));
+  }
+  handleCursor(action) {
+    switch (action) {
+      case "up":
+        this.state_data.cursor = Math.max(0, this.state_data.cursor - 1);
+        this.adjustScroll();
+        break;
+      case "down":
+        this.state_data.cursor = Math.min(
+          this.state_data.skills.length - 1,
+          this.state_data.cursor + 1
+        );
+        this.adjustScroll();
+        break;
+      case "space":
+        this.toggleCurrent();
+        break;
+    }
+  }
+  adjustScroll() {
+    if (this.state_data.cursor < this.state_data.scrollOffset) {
+      this.state_data.scrollOffset = this.state_data.cursor;
+    } else if (this.state_data.cursor >= this.state_data.scrollOffset + this.maxItems) {
+      this.state_data.scrollOffset = this.state_data.cursor - this.maxItems + 1;
+    }
+  }
+  toggleCurrent() {
+    const skill = this.state_data.skills[this.state_data.cursor];
+    if (!skill) return;
+    const key = getSkillKey(skill);
+    const currentState = this.state_data.changes.has(key) ? this.state_data.changes.get(key) : skill.enabled;
+    this.state_data.changes.set(key, !currentState);
+  }
+  getEffectiveState(skill) {
+    const key = getSkillKey(skill);
+    return this.state_data.changes.has(key) ? this.state_data.changes.get(key) : skill.enabled;
+  }
+  renderPrompt() {
+    const lines = [];
+    const { skills, cursor, scrollOffset, changes } = this.state_data;
+    lines.push(`${import_picocolors2.default.gray(S_BAR2)}`);
+    lines.push(`${symbol2(this.state)}  Manage installed skills`);
+    if (this.state === "submit") {
+      const changeCount2 = changes.size;
+      if (changeCount2 === 0) {
+        lines.push(`${import_picocolors2.default.gray(S_BAR2)}  ${import_picocolors2.default.dim("No changes")}`);
+      } else {
+        lines.push(`${import_picocolors2.default.gray(S_BAR2)}  ${import_picocolors2.default.dim(`${changeCount2} change(s) applied`)}`);
+      }
+      return lines.join("\n");
+    }
+    if (this.state === "cancel") {
+      lines.push(`${import_picocolors2.default.gray(S_BAR2)}  ${import_picocolors2.default.dim("Cancelled")}`);
+      lines.push(`${import_picocolors2.default.gray(S_BAR2)}`);
+      return lines.join("\n");
+    }
+    if (skills.length === 0) {
+      lines.push(`${import_picocolors2.default.cyan(S_BAR2)}`);
+      lines.push(`${import_picocolors2.default.cyan(S_BAR2)}  ${import_picocolors2.default.dim("No skills installed")}`);
+      lines.push(`${import_picocolors2.default.cyan(S_BAR2)}  ${import_picocolors2.default.dim('Use "skai <source>" to install skills')}`);
+      lines.push(`${import_picocolors2.default.cyan(S_BAR_END2)}`);
+      return lines.join("\n");
+    }
+    const changeCount = changes.size;
+    const changeText = changeCount > 0 ? import_picocolors2.default.yellow(` \u2022 ${changeCount} pending change(s)`) : "";
+    lines.push(
+      `${import_picocolors2.default.cyan(S_BAR2)}  ${import_picocolors2.default.dim("\u2191/\u2193 navigate \u2022 space toggle \u2022 enter apply")}${changeText}`
+    );
+    lines.push(`${import_picocolors2.default.cyan(S_BAR2)}  ${import_picocolors2.default.dim("\u2500".repeat(50))}`);
+    const headerName = "SKILL".padEnd(MAX_NAME_WIDTH);
+    const headerAgent = "AGENT".padEnd(MAX_AGENT_WIDTH);
+    const headerScope = "SCOPE".padEnd(8);
+    const headerStatus = "STATUS";
+    lines.push(
+      `${import_picocolors2.default.cyan(S_BAR2)}  ${import_picocolors2.default.dim("   " + headerName + headerAgent + headerScope + headerStatus)}`
+    );
+    const aboveCount = scrollOffset;
+    const belowCount = Math.max(0, skills.length - scrollOffset - this.maxItems);
+    if (aboveCount > 0) {
+      lines.push(`${import_picocolors2.default.cyan(S_BAR2)}  ${import_picocolors2.default.dim(`\u2191 ${aboveCount} more above`)}`);
+    }
+    const visibleSkills = skills.slice(scrollOffset, scrollOffset + this.maxItems);
+    for (let i = 0; i < visibleSkills.length; i++) {
+      const skill = visibleSkills[i];
+      const globalIndex = scrollOffset + i;
+      const isActive = globalIndex === cursor;
+      const enabled = this.getEffectiveState(skill);
+      const wasChanged = changes.has(getSkillKey(skill));
+      let toggle;
+      if (isActive && enabled) {
+        toggle = S_TOGGLE_ACTIVE_ON;
+      } else if (isActive && !enabled) {
+        toggle = S_TOGGLE_ACTIVE_OFF;
+      } else if (enabled) {
+        toggle = S_TOGGLE_ON;
+      } else {
+        toggle = S_TOGGLE_OFF;
+      }
+      const name = skill.name.length > MAX_NAME_WIDTH ? skill.name.slice(0, MAX_NAME_WIDTH - 2) + ".." : skill.name.padEnd(MAX_NAME_WIDTH);
+      const agent = skill.agent.displayName.length > MAX_AGENT_WIDTH ? skill.agent.displayName.slice(0, MAX_AGENT_WIDTH - 2) + ".." : skill.agent.displayName.padEnd(MAX_AGENT_WIDTH);
+      const scope = skill.scope.padEnd(8);
+      const status = enabled ? import_picocolors2.default.green("enabled") : import_picocolors2.default.dim("disabled");
+      const changedMarker = wasChanged ? import_picocolors2.default.yellow(" *") : "";
+      const line = isActive ? `${toggle} ${name}${agent}${scope}${status}${changedMarker}` : `${toggle} ${import_picocolors2.default.dim(name)}${import_picocolors2.default.dim(agent)}${import_picocolors2.default.dim(scope)}${status}${changedMarker}`;
+      lines.push(`${import_picocolors2.default.cyan(S_BAR2)}  ${line}`);
+    }
+    if (belowCount > 0) {
+      lines.push(`${import_picocolors2.default.cyan(S_BAR2)}  ${import_picocolors2.default.dim(`\u2193 ${belowCount} more below`)}`);
+    }
+    lines.push(`${import_picocolors2.default.cyan(S_BAR_END2)}`);
+    return lines.join("\n");
+  }
+  async run() {
+    const result = await this.prompt();
+    if (BD(result)) {
+      return result;
+    }
+    return {
+      skills: this.state_data.skills,
+      changes: this.state_data.changes
+    };
+  }
+};
+async function manageSkills() {
+  let targetAgents = detectInstalledAgents();
+  if (targetAgents.length === 0) {
+    targetAgents = getAllAgents();
+  }
+  const allSkills = [];
+  for (const agent of targetAgents) {
+    const skills2 = listManagedSkills(agent);
+    allSkills.push(...skills2);
+  }
+  allSkills.sort((a, b2) => {
+    const agentCmp = a.agent.displayName.localeCompare(b2.agent.displayName);
+    if (agentCmp !== 0) return agentCmp;
+    const scopeCmp = a.scope.localeCompare(b2.scope);
+    if (scopeCmp !== 0) return scopeCmp;
+    return a.name.localeCompare(b2.name);
+  });
+  const prompt = new SkillManagerPrompt(allSkills);
+  const result = await prompt.run();
+  if (BD(result)) {
+    return null;
+  }
+  const { skills, changes } = result;
+  if (changes.size === 0) {
+    return { enabled: 0, disabled: 0, failed: 0, errors: [] };
+  }
+  const results = { enabled: 0, disabled: 0, failed: 0, errors: [] };
+  for (const skill of skills) {
+    const key = getSkillKey(skill);
+    if (!changes.has(key)) continue;
+    const newState = changes.get(key);
+    if (newState === skill.enabled) continue;
+    const toggleResult = toggleSkill(skill);
+    if (toggleResult.success) {
+      if (toggleResult.enabled) {
+        results.enabled++;
+      } else {
+        results.disabled++;
+      }
+    } else {
+      results.failed++;
+      results.errors.push({
+        skill: skill.name,
+        agent: skill.agent.displayName,
+        error: toggleResult.error || "Unknown error"
+      });
+    }
+  }
+  return results;
+}
+
 // src/dependencies.ts
 import * as fs6 from "fs";
 import * as path6 from "path";
@@ -1856,14 +2191,70 @@ function printSkillTree(node, indent = 0) {
     console.log(chalk.green(`\u2502 ${prefix}\u2022 ${s.name}`) + desc);
   }
 }
-async function main() {
-  const program = new Command();
-  program.name("skai").description("The package manager for AI agent skills").version(getVersion(), "-V, --version", "Display version").argument("[source]", "GitHub repo, URL, or local path to install skills from").option("-g, --global", "Install to user directory instead of project", false).option("-a, --agent <agents...>", "Target specific agents").option("-s, --skill <skills...>", "Install specific skills by name").option("-l, --list", "List available skills without installing", false).option("-y, --yes", "Skip confirmation prompts", false).option("--json", "Output results in JSON format", false).action(async (source, options) => {
-    await run(source, options);
-  });
-  await program.parseAsync(process.argv);
+function formatGitError(error, url) {
+  const msg = error.message.toLowerCase();
+  if (msg.includes("authentication") || msg.includes("401") || msg.includes("403")) {
+    return `Authentication failed for ${url}. Check your credentials or ensure the repository is public.`;
+  }
+  if (msg.includes("not found") || msg.includes("404") || msg.includes("does not exist")) {
+    return `Repository not found: ${url}. Check the URL or owner/repo name.`;
+  }
+  if (msg.includes("timeout") || msg.includes("timed out")) {
+    return `Connection timed out while cloning ${url}. Check your network connection.`;
+  }
+  if (msg.includes("could not resolve host") || msg.includes("network")) {
+    return `Network error while cloning ${url}. Check your internet connection.`;
+  }
+  if (msg.includes("permission denied")) {
+    return `Permission denied when accessing ${url}. The repository may be private.`;
+  }
+  return `Failed to clone repository: ${error.message}`;
+}
+function formatInstallStatus(statuses, isDryRun) {
+  if (statuses.length === 0) return;
+  const grouped = /* @__PURE__ */ new Map();
+  for (const status of statuses) {
+    const key = status.agentName;
+    if (!grouped.has(key)) grouped.set(key, []);
+    grouped.get(key).push(status);
+  }
+  for (const [agent, skills] of grouped) {
+    console.log(chalk.bold(`
+${agent}:`));
+    for (const skill of skills) {
+      let icon;
+      let color3;
+      let suffix = "";
+      switch (skill.status) {
+        case "installed":
+          icon = "\u2713";
+          color3 = chalk.green;
+          suffix = skill.path ? chalk.dim(` \u2192 ${skill.path}`) : "";
+          break;
+        case "would-install":
+          icon = "\u25CB";
+          color3 = chalk.cyan;
+          suffix = skill.path ? chalk.dim(` \u2192 ${skill.path}`) : "";
+          break;
+        case "skipped":
+          icon = "\u2013";
+          color3 = chalk.yellow;
+          suffix = skill.reason ? chalk.dim(` (${skill.reason})`) : "";
+          break;
+        case "failed":
+          icon = "\u2717";
+          color3 = chalk.red;
+          suffix = skill.reason ? chalk.dim(` (${skill.reason})`) : "";
+          break;
+      }
+      console.log(`  ${color3(icon)} ${skill.skillName}${suffix}`);
+    }
+  }
+  if (isDryRun) {
+    console.log(chalk.cyan("\n(dry-run mode - no changes made)"));
+  }
 }
-async function run(source, options) {
+async function runInstall(source, options) {
   let tempDirToClean = null;
   const handleSignal = () => {
     if (tempDirToClean) {
@@ -1880,11 +2271,6 @@ async function run(source, options) {
   clack.intro(chalk.cyan("skai - AI Agent Skills Package Manager"));
   if (!source) {
     clack.log.error("Please provide a source (GitHub repo, URL, or local path)");
-    clack.log.info("Usage: skai <source> [options]");
-    clack.log.info("Examples:");
-    clack.log.info("  skai pproenca/dot-skills");
-    clack.log.info("  skai https://github.com/org/repo");
-    clack.log.info("  skai ./local/skills");
     clack.outro(chalk.red("No source provided"));
     process.exit(EXIT_ERROR);
   }
@@ -1898,6 +2284,9 @@ async function run(source, options) {
       if (!parsed.localPath) {
         throw new Error("Local path not found in parsed source");
       }
+      if (!fs7.existsSync(parsed.localPath)) {
+        throw new Error(`Local path does not exist: ${parsed.localPath}`);
+      }
       skillsBasePath = parsed.localPath;
       clack.log.info(`Using local path: ${skillsBasePath}`);
     } else {
@@ -1914,7 +2303,8 @@ async function run(source, options) {
         spinner2.stop("Repository cloned");
       } catch (error) {
         spinner2.stop("Failed to clone repository");
-        throw error;
+        const formattedError = formatGitError(error, parsed.url || source);
+        throw new Error(formattedError);
       }
     }
     const discoverSpinner = clack.spinner();
@@ -1923,6 +2313,7 @@ async function run(source, options) {
     discoverSpinner.stop(`Found ${skills.length} skill(s)`);
     if (skills.length === 0) {
       clack.log.warn("No skills found in the repository");
+      clack.log.info("Skills must have a SKILL.md file with frontmatter metadata.");
       clack.outro(chalk.yellow("No skills to install"));
       return;
     }
@@ -1956,12 +2347,24 @@ async function run(source, options) {
     }
     let targetAgents;
     if (options.agent && options.agent.length > 0) {
-      targetAgents = options.agent.map((name) => getAgentByName(name)).filter((a) => a !== void 0);
-      if (targetAgents.length === 0) {
-        clack.log.error(`No valid agents found for: ${options.agent.join(", ")}`);
+      const invalidAgents = [];
+      targetAgents = [];
+      for (const name of options.agent) {
+        const agent = getAgentByName(name);
+        if (agent) {
+          targetAgents.push(agent);
+        } else {
+          invalidAgents.push(name);
+        }
+      }
+      if (invalidAgents.length > 0) {
+        clack.log.warn(`Unknown agent(s): ${invalidAgents.join(", ")}`);
         clack.log.info(
           `Available agents: ${getAllAgents().map((a) => a.name).join(", ")}`
         );
+      }
+      if (targetAgents.length === 0) {
+        clack.log.error("No valid agents specified");
         clack.outro(chalk.red("No valid agents"));
         return;
       }
@@ -2053,6 +2456,44 @@ async function run(source, options) {
       }
       isGlobal = scope === "global";
     }
+    if (options.dryRun) {
+      const statuses2 = [];
+      const installOptions2 = { global: isGlobal, yes: options.yes };
+      for (const skill of selectedSkills) {
+        for (const agent of selectedAgents) {
+          const targetPath = getSkillInstallPath(skill.name, agent, installOptions2);
+          if (isSkillInstalled(skill, agent, installOptions2)) {
+            statuses2.push({
+              skillName: skill.name,
+              agentName: agent.displayName,
+              status: "skipped",
+              path: targetPath,
+              reason: "already installed"
+            });
+          } else {
+            statuses2.push({
+              skillName: skill.name,
+              agentName: agent.displayName,
+              status: "would-install",
+              path: targetPath
+            });
+          }
+        }
+      }
+      if (options.json) {
+        const jsonOutput = {
+          dry_run: true,
+          would_install: statuses2.filter((s) => s.status === "would-install").map((s) => ({ skill: s.skillName, agent: s.agentName, path: s.path })),
+          would_skip: statuses2.filter((s) => s.status === "skipped").map((s) => ({ skill: s.skillName, agent: s.agentName, reason: s.reason }))
+        };
+        console.log(JSON.stringify(jsonOutput, null, 2));
+        return;
+      }
+      clack.log.info(chalk.bold("\nDry Run - Installation Preview:"));
+      formatInstallStatus(statuses2, true);
+      clack.outro(chalk.cyan("Dry run complete"));
+      return;
+    }
     if (!options.yes) {
       const summary = [
         `Skills: ${selectedSkills.map((s) => s.name).join(", ")}`,
@@ -2079,20 +2520,41 @@ Installation Summary:
     };
     const installOptions = { global: isGlobal, yes: options.yes };
     const installedSkillNames = [];
+    const statuses = [];
     for (const skill of selectedSkills) {
       for (const agent of selectedAgents) {
+        const targetPath = getSkillInstallPath(skill.name, agent, installOptions);
         if (isSkillInstalled(skill, agent, installOptions)) {
           results.skipped++;
+          statuses.push({
+            skillName: skill.name,
+            agentName: agent.displayName,
+            status: "skipped",
+            path: targetPath,
+            reason: "already installed"
+          });
           continue;
         }
         const result = installSkillForAgent(skill, agent, installOptions);
         if (result.success) {
           results.success++;
+          statuses.push({
+            skillName: skill.name,
+            agentName: agent.displayName,
+            status: "installed",
+            path: result.targetPath
+          });
           if (!installedSkillNames.includes(skill.name)) {
             installedSkillNames.push(skill.name);
           }
         } else {
           results.failed++;
+          statuses.push({
+            skillName: skill.name,
+            agentName: agent.displayName,
+            status: "failed",
+            reason: result.error
+          });
           if (!options.json) {
             clack.log.warn(`Failed to install ${skill.name} to ${agent.displayName}: ${result.error}`);
           }
@@ -2100,6 +2562,9 @@ Installation Summary:
       }
     }
     installSpinner.stop(`Installed ${results.success} skill(s)`);
+    if (!options.json && statuses.length > 0) {
+      formatInstallStatus(statuses, false);
+    }
     const depSpinner = clack.spinner();
     depSpinner.start("Scanning for dependencies...");
     const skillDeps = [];
@@ -2251,6 +2716,278 @@ Installation Summary:
     }
   }
 }
+async function runUninstall(skillNames, options) {
+  clack.intro(chalk.cyan("skai uninstall"));
+  if (skillNames.length === 0) {
+    clack.log.error("Please provide at least one skill name to uninstall");
+    clack.log.info("Usage: skai uninstall <skill> [skill...] [-a <agent>]");
+    clack.outro(chalk.red("No skills specified"));
+    process.exit(EXIT_ERROR);
+  }
+  let targetAgents;
+  if (options.agent && options.agent.length > 0) {
+    targetAgents = options.agent.map((name) => getAgentByName(name)).filter((a) => a !== void 0);
+    if (targetAgents.length === 0) {
+      clack.log.error(`No valid agents found for: ${options.agent.join(", ")}`);
+      clack.log.info(
+        `Available agents: ${getAllAgents().map((a) => a.name).join(", ")}`
+      );
+      clack.outro(chalk.red("No valid agents"));
+      process.exit(EXIT_ERROR);
+    }
+  } else {
+    targetAgents = detectInstalledAgents();
+    if (targetAgents.length === 0) {
+      targetAgents = getAllAgents();
+    }
+  }
+  const toUninstall = [];
+  for (const skillName of skillNames) {
+    for (const agent of targetAgents) {
+      const projectInstalled = listInstalledSkills(agent, { projectOnly: true }).some((s) => s.name === skillName);
+      const globalInstalled = listInstalledSkills(agent, { global: true }).some((s) => s.name === skillName);
+      if (options.global && globalInstalled) {
+        toUninstall.push({ skill: skillName, agent, scope: "global" });
+      } else if (!options.global && projectInstalled) {
+        toUninstall.push({ skill: skillName, agent, scope: "project" });
+      } else if (!options.global && globalInstalled) {
+        toUninstall.push({ skill: skillName, agent, scope: "global" });
+      }
+    }
+  }
+  if (toUninstall.length === 0) {
+    clack.log.warn("No installed skills found matching the specified names");
+    clack.outro(chalk.yellow("Nothing to uninstall"));
+    return;
+  }
+  if (!options.yes) {
+    clack.log.info(chalk.bold("\nSkills to uninstall:"));
+    for (const item of toUninstall) {
+      clack.log.info(`  \u2022 ${item.skill} from ${item.agent.displayName} (${item.scope})`);
+    }
+    const confirmed = await clack.confirm({
+      message: `Uninstall ${toUninstall.length} skill(s)?`
+    });
+    if (clack.isCancel(confirmed) || !confirmed) {
+      clack.outro(chalk.yellow("Cancelled"));
+      return;
+    }
+  }
+  const results = { success: 0, failed: 0 };
+  const uninstalledSkills = [];
+  const errors = [];
+  for (const item of toUninstall) {
+    const installOptions = { global: item.scope === "global", yes: options.yes };
+    const result = uninstallSkill(item.skill, item.agent, installOptions);
+    if (result.success) {
+      results.success++;
+      if (!uninstalledSkills.includes(item.skill)) {
+        uninstalledSkills.push(item.skill);
+      }
+      if (!options.json) {
+        clack.log.info(chalk.green(`\u2713 Uninstalled ${item.skill} from ${item.agent.displayName}`));
+      }
+    } else {
+      results.failed++;
+      errors.push({ skill: item.skill, agent: item.agent.displayName, error: result.error || "Unknown error" });
+      if (!options.json) {
+        clack.log.warn(`\u2717 Failed to uninstall ${item.skill} from ${item.agent.displayName}: ${result.error}`);
+      }
+    }
+  }
+  if (options.json) {
+    const jsonOutput = {
+      skills_uninstalled: uninstalledSkills,
+      errors
+    };
+    console.log(JSON.stringify(jsonOutput, null, 2));
+    return;
+  }
+  const resultParts = [];
+  if (results.success > 0) resultParts.push(chalk.green(`${results.success} uninstalled`));
+  if (results.failed > 0) resultParts.push(chalk.red(`${results.failed} failed`));
+  clack.outro(resultParts.join(", ") || chalk.green("Done"));
+}
+async function runList(options) {
+  if (!options.json) {
+    clack.intro(chalk.cyan("skai list"));
+  }
+  let targetAgents;
+  if (options.agent && options.agent.length > 0) {
+    targetAgents = options.agent.map((name) => getAgentByName(name)).filter((a) => a !== void 0);
+    if (targetAgents.length === 0 && !options.json) {
+      clack.log.error(`No valid agents found for: ${options.agent.join(", ")}`);
+      clack.log.info(
+        `Available agents: ${getAllAgents().map((a) => a.name).join(", ")}`
+      );
+      clack.outro(chalk.red("No valid agents"));
+      process.exit(EXIT_ERROR);
+    }
+  } else {
+    targetAgents = detectInstalledAgents();
+    if (targetAgents.length === 0) {
+      targetAgents = getAllAgents();
+    }
+  }
+  const allSkills = [];
+  const agentSkillsMap = /* @__PURE__ */ new Map();
+  for (const agent of targetAgents) {
+    const skills = listInstalledSkills(agent, { global: options.global });
+    const projectSkills = [];
+    const globalSkills = [];
+    for (const skill of skills) {
+      allSkills.push({
+        name: skill.name,
+        path: skill.path,
+        agent: agent.displayName,
+        scope: skill.scope
+      });
+      if (skill.scope === "project") {
+        projectSkills.push(skill.name);
+      } else {
+        globalSkills.push(skill.name);
+      }
+    }
+    if (projectSkills.length > 0 || globalSkills.length > 0) {
+      agentSkillsMap.set(agent.displayName, { project: projectSkills, global: globalSkills });
+    }
+  }
+  if (options.json) {
+    const jsonOutput = { skills: allSkills };
+    console.log(JSON.stringify(jsonOutput, null, 2));
+    return;
+  }
+  if (allSkills.length === 0) {
+    clack.log.info("No skills installed");
+    clack.outro(chalk.dim('Use "skai <source>" to install skills'));
+    return;
+  }
+  for (const [agentName, skills] of agentSkillsMap) {
+    console.log(chalk.bold(`
+${agentName}:`));
+    if (skills.project.length > 0) {
+      console.log(chalk.dim("  Project:"));
+      for (const skill of skills.project.sort()) {
+        console.log(chalk.green(`    \u2022 ${skill}`));
+      }
+    }
+    if (skills.global.length > 0) {
+      console.log(chalk.dim("  Global:"));
+      for (const skill of skills.global.sort()) {
+        console.log(chalk.blue(`    \u2022 ${skill}`));
+      }
+    }
+  }
+  clack.outro(chalk.cyan(`${allSkills.length} skill(s) installed`));
+}
+async function runUpdate(_skillNames, _options) {
+  clack.intro(chalk.cyan("skai update"));
+  clack.log.warn("The update command requires tracking skill sources.");
+  clack.log.info("Currently, skai does not track where skills were installed from.");
+  clack.log.info("");
+  clack.log.info("To update a skill, you can:");
+  clack.log.info("  1. Uninstall the existing skill: skai uninstall <skill>");
+  clack.log.info("  2. Reinstall from the source: skai <source>");
+  clack.outro(chalk.yellow("Update not yet implemented"));
+}
+async function runManage() {
+  if (!process.stdin.isTTY) {
+    clack.log.error("Interactive mode requires a TTY.");
+    clack.log.info('Use "skai list" to view installed skills.');
+    process.exit(EXIT_ERROR);
+  }
+  clack.intro(chalk.cyan("skai - Skill Manager"));
+  const result = await manageSkills();
+  if (result === null) {
+    clack.outro(chalk.yellow("Cancelled"));
+    return;
+  }
+  if (result.enabled === 0 && result.disabled === 0 && result.failed === 0) {
+    clack.outro(chalk.dim("No changes made"));
+    return;
+  }
+  const parts = [];
+  if (result.enabled > 0) parts.push(chalk.green(`${result.enabled} enabled`));
+  if (result.disabled > 0) parts.push(chalk.yellow(`${result.disabled} disabled`));
+  if (result.failed > 0) parts.push(chalk.red(`${result.failed} failed`));
+  for (const err of result.errors) {
+    clack.log.warn(`Failed to update ${err.skill} (${err.agent}): ${err.error}`);
+  }
+  if (result.enabled > 0 || result.disabled > 0) {
+    clack.note("Restart your AI agent to apply changes.", "Next steps");
+  }
+  clack.outro(parts.join(", "));
+}
+async function main() {
+  const program = new Command();
+  program.name("skai").description("The package manager for AI agent skills").version(getVersion(), "-V, --version", "Display version");
+  program.argument("[source]", "GitHub repo, URL, or local path to install skills from").option("-g, --global", "Install to user directory instead of project", false).option("-a, --agent <agents...>", "Target specific agents").option("-s, --skill <skills...>", "Install specific skills by name").option("-l, --list", "List available skills without installing", false).option("-y, --yes", "Skip confirmation prompts", false).option("--json", "Output results in JSON format", false).option("--dry-run", "Preview installation without making changes", false).action(async (source, options) => {
+    if (!source) {
+      await runManage();
+      return;
+    }
+    await runInstall(source, options);
+  });
+  program.command("install <source>").description("Install skills from a source").option("-g, --global", "Install to user directory instead of project", false).option("-a, --agent <agents...>", "Target specific agents").option("-s, --skill <skills...>", "Install specific skills by name").option("-l, --list", "List available skills without installing", false).option("-y, --yes", "Skip confirmation prompts", false).option("--json", "Output results in JSON format", false).option("--dry-run", "Preview installation without making changes", false).action(async (source, options) => {
+    await runInstall(source, options);
+  });
+  program.command("uninstall <skills...>").alias("rm").alias("remove").description("Uninstall skills from agents").option("-g, --global", "Uninstall from global directory", false).option("-a, --agent <agents...>", "Target specific agents").option("-y, --yes", "Skip confirmation prompts", false).option("--json", "Output results in JSON format", false).action(async (skills, options) => {
+    await runUninstall(skills, options);
+  });
+  program.command("list").alias("ls").description("List installed skills").option("-g, --global", "List only global skills", false).option("-a, --agent <agents...>", "Target specific agents").option("--json", "Output results in JSON format", false).action(async (options) => {
+    await runList(options);
+  });
+  program.command("update [skills...]").alias("up").description("Update installed skills (coming soon)").option("-g, --global", "Update global skills", false).option("-a, --agent <agents...>", "Target specific agents").option("-y, --yes", "Skip confirmation prompts", false).option("--json", "Output results in JSON format", false).action(async (skills, options) => {
+    await runUpdate(skills, options);
+  });
+  program.command("manage").description("Interactively enable/disable installed skills").action(async () => {
+    await runManage();
+  });
+  program.addHelpText(
+    "after",
+    `
+${chalk.yellow("EXAMPLES")}
+  ${chalk.dim("# Install skills from GitHub")}
+  $ skai pproenca/dot-skills
+
+  ${chalk.dim("# Install from full URL")}
+  $ skai https://github.com/org/repo
+
+  ${chalk.dim("# Install from local directory")}
+  $ skai ./local/skills
+
+  ${chalk.dim("# Install specific skill to specific agent")}
+  $ skai pproenca/dot-skills -s typescript -a claude-code
+
+  ${chalk.dim("# Preview installation without changes")}
+  $ skai pproenca/dot-skills --dry-run
+
+  ${chalk.dim("# List installed skills")}
+  $ skai list
+
+  ${chalk.dim("# List skills for specific agent")}
+  $ skai list -a cursor
+
+  ${chalk.dim("# Uninstall a skill")}
+  $ skai uninstall typescript
+
+  ${chalk.dim("# Uninstall from specific agent")}
+  $ skai uninstall typescript -a cursor
+
+  ${chalk.dim("# Manage skills (enable/disable)")}
+  $ skai
+  $ skai manage
+
+${chalk.yellow("SUPPORTED AGENTS")}
+  claude-code, cursor, copilot, windsurf, codex, opencode, amp,
+  kilo-code, roo-code, goose, gemini, antigravity, clawdbot, droid
+
+${chalk.yellow("LEARN MORE")}
+  GitHub: ${chalk.cyan("https://github.com/pproenca/skai")}
+`
+  );
+  await program.parseAsync(process.argv);
+}
 main().catch((error) => {
   console.error(chalk.red("Fatal error:"), error);
   process.exit(EXIT_ERROR);