skai 0.0.6 → 0.0.8

package/dist/index.js

@@ -740,6 +740,79 @@ 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";
@@ -1656,6 +1729,225 @@ 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("\u25FC");
+var S_TOGGLE_OFF = import_picocolors2.default.dim("\u25FB");
+var S_TOGGLE_ACTIVE_ON = import_picocolors2.default.green("\u25FC");
+var S_TOGGLE_ACTIVE_OFF = import_picocolors2.default.cyan("\u25FB");
+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";
+    lines.push(
+      `${import_picocolors2.default.cyan(S_BAR2)}  ${import_picocolors2.default.dim("   " + headerName + headerAgent + headerScope)}`
+    );
+    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;
+      const changedMarker = wasChanged ? import_picocolors2.default.yellow(" *") : "";
+      const line = isActive ? `${toggle} ${name}${agent}${scope}${changedMarker}` : `${toggle} ${import_picocolors2.default.dim(name)}${import_picocolors2.default.dim(agent)}${import_picocolors2.default.dim(scope)}${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";
@@ -1929,31 +2221,31 @@ function formatInstallStatus(statuses, isDryRun) {
 ${agent}:`));
     for (const skill of skills) {
       let icon;
-      let color2;
+      let color3;
       let suffix = "";
       switch (skill.status) {
         case "installed":
           icon = "\u2713";
-          color2 = chalk.green;
+          color3 = chalk.green;
           suffix = skill.path ? chalk.dim(` \u2192 ${skill.path}`) : "";
           break;
         case "would-install":
           icon = "\u25CB";
-          color2 = chalk.cyan;
+          color3 = chalk.cyan;
           suffix = skill.path ? chalk.dim(` \u2192 ${skill.path}`) : "";
           break;
         case "skipped":
           icon = "\u2013";
-          color2 = chalk.yellow;
+          color3 = chalk.yellow;
           suffix = skill.reason ? chalk.dim(` (${skill.reason})`) : "";
           break;
         case "failed":
           icon = "\u2717";
-          color2 = chalk.red;
+          color3 = chalk.red;
           suffix = skill.reason ? chalk.dim(` (${skill.reason})`) : "";
           break;
       }
-      console.log(`  ${color2(icon)} ${skill.skillName}${suffix}`);
+      console.log(`  ${color3(icon)} ${skill.skillName}${suffix}`);
     }
   }
   if (isDryRun) {
@@ -1977,12 +2269,6 @@ async function runInstall(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("");
-    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);
   }
@@ -2602,10 +2888,42 @@ async function runUpdate(_skillNames, _options) {
   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) => {
@@ -2620,24 +2938,50 @@ async function main() {
   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",
     `
-Examples:
-  $ skai pproenca/dot-skills              Install skills from GitHub
-  $ skai https://github.com/org/repo      Install from full URL
-  $ skai ./local/skills                   Install from local directory
-  $ skai pproenca/dot-skills -s typescript  Install specific skill
-  $ skai pproenca/dot-skills -a claude-code Install to specific agent
-  $ skai pproenca/dot-skills --dry-run    Preview installation
-  $ skai list                             List installed skills
-  $ skai list -a cursor                   List skills for specific agent
-  $ skai uninstall typescript             Uninstall a skill
-  $ skai uninstall typescript -a cursor   Uninstall from specific agent
+${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
 
-Supported Agents:
+  ${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);