@kurokeita/add-skill 1.7.0 → 1.9.0

package/dist/bin/cli.js

@@ -1,29 +1,1022 @@
 #!/usr/bin/env node
+
+// bin/cli.ts
+import { intro as intro5, isCancel as isCancel5, outro as outro5, select as select5 } from "@clack/prompts";
 import { Command } from "commander";
-import { add } from "../src/commands/add.js";
-import { importItem } from "../src/commands/import.js";
-import { list } from "../src/commands/list.js";
-import { remove } from "../src/commands/remove.js";
-const program = new Command();
-program
-    .name("ai-agent")
-    .description("CLI to manage AI agents, skills, and workflows")
-    .version("1.4.0");
-program
-    .command("list [type]")
-    .description("List available items (skills, agents, workflows)")
-    .option("-l, --local", "List installed items locally")
-    .action(list);
-program
-    .command("add <type> [url]")
-    .description("Add an item (skill, agent, workflow) to platforms (Interactive or from GitHub URL)")
-    .action(add);
-program
-    .command("import <type> <url>")
-    .description("Import an item from GitHub to the repo")
-    .action(importItem);
-program
-    .command("remove <type>")
-    .description("Remove locally installed items (skills, agents, workflows)")
-    .action(remove);
-program.parse();
+import pc5 from "picocolors";
+
+// src/commands/add.ts
+import os3 from "node:os";
+import path4 from "node:path";
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  multiselect,
+  note,
+  outro,
+  select,
+  spinner
+} from "@clack/prompts";
+import fs2 from "fs-extra";
+import pc from "picocolors";
+
+// src/utils/github.ts
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+async function fetchSkillFromGitHub(url) {
+  const regex = /github\.com\/([^/]+)\/([^/]+)\/(?:tree|blob)\/([^/]+)\/(.+)/;
+  const match = url.match(regex);
+  if (!match) {
+    throw new Error(
+      "Invalid GitHub URL. Format: https://github.com/owner/repo/tree/branch/path/to/skill or blob/branch/path/to/file"
+    );
+  }
+  const [, owner, repo, ref, skillPath] = match;
+  const skillName = path.basename(skillPath);
+  const initialApiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${skillPath}?ref=${ref}`;
+  const tempDir = path.join(os.tmpdir(), "ai-agents-install", skillName);
+  await fs.ensureDir(tempDir);
+  await fs.emptyDir(tempDir);
+  let isFile = false;
+  async function downloadDirectory(apiUrl, localDir) {
+    const response = await fetch(apiUrl, {
+      headers: {
+        "User-Agent": "ai-agents-cli",
+        Accept: "application/vnd.github.v3+json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch from GitHub (${response.status}): ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    if (!Array.isArray(data) && data.type === "file") {
+      isFile = true;
+      const item = data;
+      if (item.download_url) {
+        const fileContentResponse = await fetch(item.download_url);
+        if (!fileContentResponse.ok) {
+          throw new Error(
+            `Failed to download ${item.name}: ${fileContentResponse.statusText}`
+          );
+        }
+        const content = await fileContentResponse.text();
+        await fs.writeFile(path.join(localDir, item.name), content);
+      }
+      return;
+    }
+    if (!Array.isArray(data)) {
+      throw new Error(
+        "Invalid response from GitHub API. Expected directory listing or file object."
+      );
+    }
+    const files = data;
+    for (const item of files) {
+      if (item.type === "file" && item.download_url) {
+        const fileContentResponse = await fetch(item.download_url);
+        if (!fileContentResponse.ok) {
+          console.warn(
+            `Failed to download ${item.name}: ${fileContentResponse.statusText}`
+          );
+          continue;
+        }
+        const content = await fileContentResponse.text();
+        await fs.writeFile(path.join(localDir, item.name), content);
+      } else if (item.type === "dir") {
+        const newLocalDir = path.join(localDir, item.name);
+        await fs.ensureDir(newLocalDir);
+        await downloadDirectory(item.url, newLocalDir);
+      }
+    }
+  }
+  await downloadDirectory(initialApiUrl, tempDir);
+  return { tempDir, skillName, isFile };
+}
+
+// src/utils/paths.ts
+import os2 from "node:os";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+var PROJECT_ROOT = path2.resolve(__dirname, "../..");
+var PLATFORM_LABELS = {
+  antigravity: "Antigravity",
+  gemini: "Gemini CLI",
+  copilot: "GitHub Copilot",
+  windsurf: "Windsurf"
+};
+var PLATFORM_PATHS_SKILLS = {
+  antigravity: path2.join(os2.homedir(), ".gemini/antigravity/global_skills"),
+  copilot: path2.join(os2.homedir(), ".copilot/skills"),
+  gemini: path2.join(os2.homedir(), ".gemini/skills"),
+  windsurf: path2.join(os2.homedir(), ".codeium/windsurf/skills")
+};
+var PLATFORM_PATHS_AGENTS = {
+  copilot: path2.join(os2.homedir(), ".copilot/agents"),
+  gemini: path2.join(os2.homedir(), ".gemini/agents")
+};
+var PLATFORM_PATHS_WORKFLOWS = {
+  antigravity: path2.join(os2.homedir(), ".gemini/antigravity/global_workflows"),
+  copilot: path2.join(os2.homedir(), ".copilot/prompts"),
+  gemini: path2.join(os2.homedir(), ".gemini/commands"),
+  windsurf: path2.join(os2.homedir(), ".codeium/windsurf/global_workflows")
+};
+var TYPE_DIRS = {
+  skill: path2.join(PROJECT_ROOT, "skills"),
+  agent: path2.join(PROJECT_ROOT, "agents"),
+  workflow: path2.join(PROJECT_ROOT, "workflows")
+};
+function getTargetPaths(type) {
+  switch (type) {
+    case "agent":
+      return PLATFORM_PATHS_AGENTS;
+    case "workflow":
+      return PLATFORM_PATHS_WORKFLOWS;
+    default:
+      return PLATFORM_PATHS_SKILLS;
+  }
+}
+
+// src/utils/platforms/antigravity.ts
+var AntigravityHandler = class {
+  platform = "antigravity";
+  getTargetFileName(itemName, _) {
+    return itemName;
+  }
+  transform(content, _, __) {
+    return content;
+  }
+};
+
+// src/utils/platforms/copilot.ts
+import yaml from "js-yaml";
+var CopilotHandler = class {
+  platform = "copilot";
+  getTargetFileName(itemName, type) {
+    if (type === "agent") {
+      return `${itemName.replace(/\.md$/, "")}.md`;
+    }
+    return itemName;
+  }
+  transform(content, type, itemName) {
+    if (type !== "agent") return content;
+    const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
+    const match = content.match(frontmatterRegex);
+    let frontmatter = {
+      name: itemName,
+      description: "",
+      target: "github-copilot",
+      tools: ["edit", "terminal", "ls", "grep_search", "githubRepo"]
+    };
+    let body = content;
+    if (match) {
+      try {
+        const parsed = yaml.load(match[1]);
+        frontmatter = { ...frontmatter, ...parsed };
+        frontmatter.target = "github-copilot";
+        frontmatter.tools = [
+          "edit",
+          "terminal",
+          "ls",
+          "grep_search",
+          "githubRepo"
+        ];
+        body = content.replace(frontmatterRegex, "").trim();
+      } catch (_) {
+      }
+    }
+    const yamlStr = yaml.dump(frontmatter);
+    return `---
+${yamlStr}---
+
+${body}`;
+  }
+};
+
+// src/utils/platforms/default.ts
+var DefaultHandler = class {
+  constructor(platform = "default") {
+    this.platform = platform;
+  }
+  getTargetFileName(itemName, _type) {
+    return itemName;
+  }
+  transform(content, _type, _itemName) {
+    return content;
+  }
+};
+
+// src/utils/platforms/gemini.ts
+import yaml2 from "js-yaml";
+
+// src/utils/toml.ts
+function convertToGeminiCommandTOML(markdownContent) {
+  const lines = markdownContent.split("\n");
+  let description = "";
+  for (let i = 0; i < lines.length; i++) {
+    const trimmedLine = lines[i].trim();
+    if (trimmedLine && trimmedLine !== "---" && !trimmedLine.startsWith("<!--")) {
+      if (trimmedLine.startsWith("#")) {
+        description = trimmedLine.replace(/^#+\s*/, "");
+      } else {
+        description = trimmedLine;
+      }
+      break;
+    }
+  }
+  if (description.length > 100) {
+    description = `${description.substring(0, 97)}...`;
+  }
+  const escapedContent = markdownContent.replace(/"""/g, '\\"\\"\\"');
+  return `description = ${JSON.stringify(description)}
+
+prompt = """
+${escapedContent.trim()}
+"""
+`;
+}
+
+// src/utils/platforms/gemini.ts
+var GeminiHandler = class {
+  platform = "gemini";
+  getTargetFileName(itemName, type) {
+    if (type === "workflow") {
+      return `${itemName.replace(/\.md$/, "")}.toml`;
+    }
+    return itemName;
+  }
+  transform(content, type, itemName) {
+    if (type === "workflow") {
+      return convertToGeminiCommandTOML(content);
+    }
+    if (type === "agent") {
+      const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
+      const match = content.match(frontmatterRegex);
+      let frontmatter = {
+        name: itemName,
+        description: "",
+        tools: [
+          "list_directory",
+          "read_file",
+          "write_file",
+          "glob",
+          "grep_search",
+          "replace",
+          "run_shell_command",
+          "google_web_search",
+          "web_fetch",
+          "ask_user",
+          "save_memory",
+          "activate_skill"
+        ]
+      };
+      let body = content;
+      if (match) {
+        try {
+          const parsed = yaml2.load(match[1]);
+          frontmatter = { ...frontmatter, ...parsed };
+          frontmatter.tools = [
+            "list_directory",
+            "read_file",
+            "write_file",
+            "glob",
+            "grep_search",
+            "replace",
+            "run_shell_command",
+            "google_web_search",
+            "web_fetch",
+            "ask_user",
+            "save_memory",
+            "activate_skill"
+          ];
+          delete frontmatter.skills;
+          body = content.replace(frontmatterRegex, "").trim();
+        } catch (_) {
+        }
+      }
+      const yamlStr = yaml2.dump(frontmatter);
+      return `---
+${yamlStr}---
+
+${body}`;
+    }
+    return content;
+  }
+};
+
+// src/utils/platforms/windsurf.ts
+import path3 from "node:path";
+var WindsurfHandler = class {
+  platform = "windsurf";
+  getTargetFileName(itemName, type) {
+    if (type === "agent") {
+      return path3.join(path3.parse(itemName).name, "AGENTS.md");
+    }
+    return itemName;
+  }
+  transform(content, _type, _itemName) {
+    return content;
+  }
+};
+
+// src/utils/platforms/index.ts
+var handlers = /* @__PURE__ */ new Map();
+function registerHandler(handler) {
+  handlers.set(handler.platform, handler);
+}
+registerHandler(new AntigravityHandler());
+registerHandler(new CopilotHandler());
+registerHandler(new GeminiHandler());
+registerHandler(new WindsurfHandler());
+function getHandler(platform) {
+  return handlers.get(platform) || new DefaultHandler(platform);
+}
+
+// src/commands/add.ts
+function getPlatformOptions(type) {
+  const paths = getTargetPaths(type);
+  return Object.entries(paths).filter(([_, pathStr]) => !!pathStr).map(([platform, pathStr]) => ({
+    label: PLATFORM_LABELS[platform],
+    value: platform,
+    hint: pathStr.replace(os3.homedir(), "~")
+  }));
+}
+async function installItem(itemName, overwrite, sourcePath, targetBaseDir) {
+  const targetPath = path4.join(targetBaseDir, itemName);
+  if (!await fs2.pathExists(sourcePath)) {
+    throw new Error(`Item '${itemName}' not found at ${sourcePath}`);
+  }
+  if (!overwrite && await fs2.pathExists(targetPath)) {
+    return false;
+  }
+  await fs2.ensureDir(targetBaseDir);
+  await fs2.copy(sourcePath, targetPath, { overwrite });
+  return true;
+}
+async function add(type, url, options) {
+  if (!options?.skipIntro) {
+    intro(pc.bgCyan(pc.black(" AI Manager : Add ")));
+  }
+  let currentType = type;
+  const isSingleShot = !!type || !!url;
+  while (true) {
+    if (!currentType && !url) {
+      const selectedType = await select({
+        message: "What would you like to add?",
+        options: [
+          { label: "Skills", value: "skill" },
+          { label: "Agents", value: "agent" },
+          { label: "Workflows", value: "workflow" },
+          { label: "Exit", value: "exit" }
+        ]
+      });
+      if (isCancel(selectedType) || selectedType === "exit") {
+        break;
+      }
+      currentType = selectedType;
+    }
+    const normalizedType = currentType?.toLowerCase().endsWith("s") && currentType.length > 1 ? currentType.slice(0, -1) : currentType ?? "";
+    if (!TYPE_DIRS[normalizedType] && !url) {
+      cancel(`Unknown type: ${currentType}. Supported: skill, agent, workflow`);
+      process.exit(1);
+      return;
+    }
+    let tempDir = null;
+    let selectedItems = [];
+    try {
+      if (url) {
+        const s2 = spinner();
+        s2.start(`Fetching ${normalizedType} from GitHub...`);
+        try {
+          const result = await fetchSkillFromGitHub(url);
+          tempDir = result.tempDir;
+          selectedItems = [result.skillName];
+          s2.stop(pc.green(`Fetched ${normalizedType}: ${result.skillName}`));
+        } catch (e) {
+          s2.stop(pc.red("Failed to fetch"));
+          throw e;
+        }
+      } else {
+        const sourceDir = TYPE_DIRS[normalizedType];
+        if (!await fs2.pathExists(sourceDir)) {
+          cancel(`${normalizedType} directory not found!`);
+          process.exit(1);
+          return;
+        }
+        const entries = await fs2.readdir(sourceDir, { withFileTypes: true });
+        const availableItems = entries.filter(
+          (entry) => entry.isDirectory() || (normalizedType === "workflow" || normalizedType === "agent") && entry.isFile() && entry.name.endsWith(".md")
+        ).map((entry) => ({ label: entry.name, value: entry.name })).sort((a, b) => a.label.localeCompare(b.label));
+        if (availableItems.length === 0) {
+          note(`No ${normalizedType}s found in directory.`, "Information");
+          if (isSingleShot) break;
+          currentType = void 0;
+          continue;
+        }
+        const items = await multiselect({
+          message: `Select ${normalizedType}s to install:`,
+          options: availableItems,
+          required: true
+        });
+        if (isCancel(items)) {
+          if (isSingleShot) break;
+          currentType = void 0;
+          continue;
+        }
+        selectedItems = items;
+      }
+      const supportedPaths = getTargetPaths(normalizedType);
+      const currentPlatformOptions = getPlatformOptions(normalizedType);
+      if (currentPlatformOptions.length === 0) {
+        cancel(`No supported platforms found for type '${normalizedType}'.`);
+        process.exit(1);
+        return;
+      }
+      const platforms = await multiselect({
+        message: "Select target platforms:",
+        options: currentPlatformOptions,
+        required: true
+      });
+      if (isCancel(platforms)) {
+        if (tempDir) await fs2.remove(tempDir);
+        if (isSingleShot) break;
+        currentType = void 0;
+        continue;
+      }
+      const selectedPlatforms = platforms;
+      const existingItems = [];
+      for (const platform of selectedPlatforms) {
+        const targetBase = supportedPaths[platform];
+        if (!targetBase) continue;
+        for (const item of selectedItems) {
+          const targetPath = path4.join(targetBase, item);
+          if (await fs2.pathExists(targetPath)) {
+            existingItems.push({ item, platform });
+          }
+        }
+      }
+      let overwrite = true;
+      if (existingItems.length > 0) {
+        const limit = 5;
+        const displayList = existingItems.slice(0, limit).map((e) => `${pc.bold(e.item)} (${e.platform})`).join(", ");
+        const remainder = existingItems.length - limit;
+        const message = remainder > 0 ? `The following items already exist: ${displayList}, and ${remainder} others.` : `The following items already exist: ${displayList}.`;
+        note(message, "Attention");
+        const shouldOverwrite = await confirm({
+          message: "Do you want to overwrite existing items?",
+          initialValue: false
+        });
+        if (isCancel(shouldOverwrite)) {
+          if (tempDir) await fs2.remove(tempDir);
+          if (isSingleShot) break;
+          currentType = void 0;
+          continue;
+        }
+        overwrite = shouldOverwrite;
+      }
+      note(
+        `Installing ${selectedItems.length} ${normalizedType}s to ${selectedPlatforms.length} platforms...`,
+        "Summary"
+      );
+      const s = spinner();
+      s.start("Installing...");
+      const errors = [];
+      let installedCount = 0;
+      let skippedCount = 0;
+      for (const platform of selectedPlatforms) {
+        const targetBase = supportedPaths[platform];
+        if (!targetBase) continue;
+        for (const item of selectedItems) {
+          const message = `Installing ${pc.bold(item)} to ${pc.cyan(platform)}...`;
+          s.message(message);
+          try {
+            let currentSourcePath;
+            if (url && tempDir) {
+              const potentialFile = path4.join(tempDir, item);
+              if (await fs2.pathExists(potentialFile) && (await fs2.stat(potentialFile)).isFile()) {
+                currentSourcePath = potentialFile;
+              } else {
+                currentSourcePath = tempDir;
+              }
+            } else {
+              const src = path4.join(TYPE_DIRS[normalizedType], item);
+              if ((await fs2.stat(src)).isFile()) {
+                currentSourcePath = src;
+              } else {
+                currentSourcePath = src;
+              }
+            }
+            const handler = getHandler(platform);
+            const targetItemName = handler.getTargetFileName(
+              item,
+              normalizedType
+            );
+            if ((normalizedType === "agent" || normalizedType === "workflow") && currentSourcePath.endsWith(".md")) {
+              const targetPath = path4.join(targetBase, targetItemName);
+              if (!overwrite && await fs2.pathExists(targetPath)) {
+                skippedCount++;
+              } else {
+                let content = await fs2.readFile(currentSourcePath, "utf-8");
+                content = handler.transform(
+                  content,
+                  normalizedType,
+                  path4.parse(item).name
+                );
+                await fs2.ensureDir(path4.dirname(targetPath));
+                await fs2.writeFile(targetPath, content);
+                installedCount++;
+              }
+              continue;
+            }
+            const installed = await installItem(
+              targetItemName,
+              overwrite,
+              currentSourcePath,
+              targetBase
+            );
+            if (installed) {
+              installedCount++;
+            } else {
+              skippedCount++;
+            }
+          } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            errors.push(`${item} -> ${platform}: ${errorMessage}`);
+          }
+        }
+      }
+      if (tempDir) {
+        await fs2.remove(tempDir);
+      }
+      if (errors.length > 0) {
+        s.stop(
+          pc.yellow(
+            `Completed with errors. Installed: ${installedCount}, Skipped: ${skippedCount}, Errors: ${errors.length}`
+          )
+        );
+        console.error(pc.red("\nErrors encountered:"));
+        for (const e of errors) {
+          console.error(pc.red(`- ${e}`));
+        }
+      } else {
+        s.stop(
+          pc.green(
+            `Successfully installed ${installedCount} ${normalizedType}s. (${skippedCount} skipped)`
+          )
+        );
+      }
+    } catch (error) {
+      if (tempDir) await fs2.remove(tempDir);
+      cancel(`An error occurred: ${error}`);
+      process.exit(1);
+      return;
+    }
+    if (isSingleShot) break;
+    currentType = void 0;
+  }
+  if (!options?.skipIntro) {
+    outro("You're all set!");
+  }
+}
+
+// src/commands/import.ts
+import path5 from "node:path";
+import {
+  cancel as cancel2,
+  confirm as confirm2,
+  intro as intro2,
+  isCancel as isCancel2,
+  outro as outro2,
+  select as select2,
+  spinner as spinner2,
+  text
+} from "@clack/prompts";
+import fs3 from "fs-extra";
+import pc2 from "picocolors";
+async function importItem(type, url, options) {
+  if (!options?.skipIntro) {
+    intro2(pc2.bgCyan(pc2.black(" AI Manager : Import ")));
+  }
+  let currentType = type;
+  if (!currentType) {
+    const selectedType = await select2({
+      message: "What would you like to import?",
+      options: [
+        { label: "Skill", value: "skill" },
+        { label: "Agent", value: "agent" },
+        { label: "Workflow", value: "workflow" }
+      ]
+    });
+    if (isCancel2(selectedType)) return;
+    currentType = selectedType;
+  }
+  const normalizedType = currentType.toLowerCase().endsWith("s") ? currentType.slice(0, -1) : currentType;
+  const targetBaseDir = TYPE_DIRS[normalizedType];
+  if (!targetBaseDir) {
+    cancel2(`Unknown type: ${currentType}. Supported: skill, agent, workflow`);
+    process.exit(1);
+    return;
+  }
+  let currentUrl = url;
+  if (!currentUrl) {
+    const inputUrl = await text({
+      message: "Enter the GitHub URL:",
+      placeholder: "https://github.com/owner/repo/tree/main/path/to/item",
+      validate: (value) => {
+        if (!value) return "URL is required.";
+        if (!value.startsWith("https://github.com/"))
+          return "Must be a GitHub URL.";
+      }
+    });
+    if (isCancel2(inputUrl)) return;
+    currentUrl = inputUrl;
+  }
+  let tempDir = null;
+  try {
+    const s = spinner2();
+    s.start(`Fetching ${normalizedType} from GitHub...`);
+    let itemName = "";
+    let isFile = false;
+    try {
+      const result = await fetchSkillFromGitHub(currentUrl);
+      tempDir = result.tempDir;
+      if (!tempDir) throw new Error("Failed to create temp directory");
+      itemName = result.skillName;
+      isFile = result.isFile;
+      s.stop(pc2.green(`Fetched: ${itemName}`));
+    } catch (e) {
+      s.stop(pc2.red("Failed to fetch"));
+      throw e;
+    }
+    const shouldFlatten = (normalizedType === "agent" || normalizedType === "workflow") && !isFile;
+    const targetPath = shouldFlatten ? targetBaseDir : path5.join(targetBaseDir, itemName);
+    if (shouldFlatten) {
+      const srcFiles = await fs3.readdir(tempDir);
+      const conflicts = [];
+      for (const file of srcFiles) {
+        if (await fs3.pathExists(path5.join(targetBaseDir, file))) {
+          conflicts.push(file);
+        }
+      }
+      if (conflicts.length > 0) {
+        const limit = 5;
+        const displayList = conflicts.slice(0, limit).join(", ");
+        const remainder = conflicts.length - limit;
+        const message = remainder > 0 ? `Files ${displayList} (and ${remainder} others) already exist in ${targetBaseDir}. Overwrite?` : `Files ${displayList} already exist in ${targetBaseDir}. Overwrite?`;
+        const shouldOverwrite = await confirm2({
+          message,
+          initialValue: false
+        });
+        if (isCancel2(shouldOverwrite) || !shouldOverwrite) {
+          await fs3.remove(tempDir);
+          return;
+        }
+      }
+    } else if (await fs3.pathExists(targetPath)) {
+      const shouldOverwrite = await confirm2({
+        message: `${normalizedType} '${itemName}' already exists in the repo. Overwrite?`,
+        initialValue: false
+      });
+      if (isCancel2(shouldOverwrite) || !shouldOverwrite) {
+        await fs3.remove(tempDir);
+        return;
+      }
+    }
+    s.start(`Importing ${itemName} to ${targetBaseDir}...`);
+    await fs3.ensureDir(targetBaseDir);
+    if (isFile) {
+      await fs3.copy(path5.join(tempDir, itemName), targetPath, {
+        overwrite: true
+      });
+    } else {
+      if (shouldFlatten) {
+        await fs3.copy(tempDir, targetBaseDir, { overwrite: true });
+      } else {
+        await fs3.copy(tempDir, targetPath, { overwrite: true });
+      }
+    }
+    s.stop(pc2.green(`Successfully imported ${itemName}!`));
+    await fs3.remove(tempDir);
+    if (!options?.skipIntro) {
+      outro2(`${normalizedType} available at: ${targetPath}`);
+    }
+  } catch (error) {
+    if (tempDir) await fs3.remove(tempDir);
+    cancel2(`An error occurred: ${error}`);
+    process.exit(1);
+    return;
+  }
+}
+
+// src/commands/list.ts
+import { intro as intro3, isCancel as isCancel3, outro as outro3, select as select3 } from "@clack/prompts";
+import fs4 from "fs-extra";
+import pc3 from "picocolors";
+async function performListing(type, local) {
+  const normalizedType = type.toLowerCase().endsWith("s") ? type.slice(0, -1) : type.toLowerCase();
+  if (local) {
+    console.log(pc3.bold(pc3.blue(`Installed ${normalizedType}s (Local):`)));
+    const targetPaths = getTargetPaths(normalizedType);
+    let foundAny = false;
+    for (const [platform, pathStr] of Object.entries(targetPaths)) {
+      const fullPath = pathStr;
+      if (await fs4.pathExists(fullPath)) {
+        const entries = await fs4.readdir(fullPath, {
+          withFileTypes: true
+        });
+        const items = entries.filter(
+          (entry) => entry.isDirectory() || entry.isFile() && entry.name.endsWith(".md")
+        ).map((entry) => entry.name).sort();
+        if (items.length > 0) {
+          foundAny = true;
+          console.log(pc3.cyan(`  ${platform}:`));
+          for (const item of items) {
+            console.log(`    - ${item}`);
+          }
+        }
+      }
+    }
+    if (!foundAny) {
+      console.log(pc3.dim(`  No installed ${normalizedType}s found.`));
+    }
+    console.log("");
+  } else {
+    if (!TYPE_DIRS[normalizedType]) {
+      console.error(
+        pc3.red(
+          `Unknown type: ${type}. Supported types: skill, agent, workflow`
+        )
+      );
+      return;
+    }
+    const dirPath = TYPE_DIRS[normalizedType];
+    if (!await fs4.pathExists(dirPath)) {
+      console.log(
+        pc3.yellow(`No ${normalizedType} directory found at: ${dirPath}`)
+      );
+      return;
+    }
+    const entries = await fs4.readdir(dirPath, { withFileTypes: true });
+    const items = entries.filter(
+      (entry) => entry.isDirectory() || normalizedType !== "skill" && entry.isFile() && entry.name.endsWith(".md")
+    ).map((entry) => entry.name).sort();
+    if (items.length > 0) {
+      console.log(pc3.bold(pc3.blue(`Available ${normalizedType}s:`)));
+      for (const item of items) {
+        console.log(`- ${item}`);
+      }
+      console.log(pc3.dim(`Total: ${items.length} ${normalizedType}s
+`));
+    } else {
+      console.log(pc3.dim(`No ${normalizedType}s found.`));
+    }
+  }
+}
+async function list(type, options) {
+  if (!options?.skipIntro) {
+    intro3(pc3.bgCyan(pc3.black(" AI Manager : List ")));
+  }
+  let currentType = type;
+  let isLocal = !!options?.local;
+  const isSingleShot = !!type;
+  try {
+    while (true) {
+      if (!currentType) {
+        const selected = await select3({
+          message: `What would you like to list? (View: ${isLocal ? "Local" : "Repository"})`,
+          options: [
+            { label: "All Skills", value: "skill" },
+            { label: "All Agents", value: "agent" },
+            { label: "All Workflows", value: "workflow" },
+            {
+              label: `Switch to ${isLocal ? "Repository" : "Local"} View`,
+              value: "toggle"
+            },
+            { label: "Exit", value: "exit" }
+          ]
+        });
+        if (isCancel3(selected) || selected === "exit") {
+          break;
+        }
+        if (selected === "toggle") {
+          isLocal = !isLocal;
+          continue;
+        }
+        currentType = selected;
+      }
+      const typesToList = currentType === "all" ? ["skill", "agent", "workflow"] : [currentType];
+      for (const t of typesToList) {
+        await performListing(t, isLocal);
+      }
+      if (isSingleShot) break;
+      currentType = void 0;
+    }
+  } catch (error) {
+    console.error(pc3.red("Error listing items:"), error);
+  }
+  if (!options?.skipIntro) {
+    outro3("Done!");
+  }
+}
+
+// src/commands/remove.ts
+import path6 from "node:path";
+import {
+  confirm as confirm3,
+  intro as intro4,
+  isCancel as isCancel4,
+  multiselect as multiselect2,
+  note as note2,
+  outro as outro4,
+  select as select4,
+  spinner as spinner3
+} from "@clack/prompts";
+import fs5 from "fs-extra";
+import pc4 from "picocolors";
+async function remove(type, options) {
+  if (!options?.skipIntro) {
+    intro4(pc4.bgCyan(pc4.black(" AI Manager : Remove ")));
+  }
+  let currentType = type;
+  const isSingleShot = !!type;
+  while (true) {
+    if (!currentType) {
+      const selectedType = await select4({
+        message: "What would you like to remove?",
+        options: [
+          { label: "Skills", value: "skill" },
+          { label: "Agents", value: "agent" },
+          { label: "Workflows", value: "workflow" },
+          { label: "Exit", value: "exit" }
+        ]
+      });
+      if (isCancel4(selectedType) || selectedType === "exit") {
+        break;
+      }
+      currentType = selectedType;
+    }
+    const normalizedType = currentType.toLowerCase().endsWith("s") ? currentType.slice(0, -1) : currentType;
+    const targetPaths = getTargetPaths(normalizedType);
+    const uniqueItems = /* @__PURE__ */ new Set();
+    const s = spinner3();
+    s.start("Scanning for installed items...");
+    for (const pathStr of Object.values(targetPaths)) {
+      if (await fs5.pathExists(pathStr)) {
+        const entries = await fs5.readdir(pathStr, {
+          withFileTypes: true
+        });
+        for (const entry of entries) {
+          if (entry.isDirectory() || normalizedType === "workflow" && entry.isFile() && entry.name.endsWith(".md") || normalizedType === "agent" && entry.isFile() && entry.name.endsWith(".md")) {
+            uniqueItems.add(entry.name);
+          }
+        }
+      }
+    }
+    s.stop(`Found ${uniqueItems.size} unique installed ${normalizedType}s.`);
+    if (uniqueItems.size === 0) {
+      note2(`No installed ${normalizedType}s found.`, "Information");
+      if (isSingleShot) break;
+      currentType = void 0;
+      continue;
+    }
+    const sortedItems = Array.from(uniqueItems).sort();
+    const itemSelections = await multiselect2({
+      message: `Select ${normalizedType}s to remove:`,
+      options: sortedItems.map((item) => ({ value: item, label: item })),
+      required: true
+    });
+    if (isCancel4(itemSelections)) {
+      if (isSingleShot) break;
+      currentType = void 0;
+      continue;
+    }
+    const selectedItems = itemSelections;
+    const platformOptions = Object.entries(targetPaths).filter(([_, pathStr]) => !!pathStr).map(([platform]) => ({
+      label: PLATFORM_LABELS[platform],
+      value: platform
+    }));
+    const platformSelections = await multiselect2({
+      message: "Select platforms to remove from:",
+      options: platformOptions,
+      required: true
+    });
+    if (isCancel4(platformSelections)) {
+      if (isSingleShot) break;
+      currentType = void 0;
+      continue;
+    }
+    const selectedPlatforms = platformSelections;
+    const confirmDelete = await confirm3({
+      message: `Are you sure you want to remove ${selectedItems.length} item(s) from ${selectedPlatforms.length} platform(s)?`,
+      initialValue: false
+    });
+    if (isCancel4(confirmDelete) || !confirmDelete) {
+      if (isSingleShot) break;
+      currentType = void 0;
+      continue;
+    }
+    const sDel = spinner3();
+    sDel.start("Removing items...");
+    let removedCount = 0;
+    let notFoundCount = 0;
+    const errors = [];
+    for (const platform of selectedPlatforms) {
+      const targetBase = targetPaths[platform];
+      if (!targetBase) continue;
+      for (const item of selectedItems) {
+        const targetPath = path6.join(targetBase, item);
+        if (await fs5.pathExists(targetPath)) {
+          sDel.message(`Removing ${pc4.bold(item)} from ${pc4.cyan(platform)}...`);
+          try {
+            await fs5.remove(targetPath);
+            removedCount++;
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`${item} (${platform}): ${msg}`);
+          }
+        } else {
+          notFoundCount++;
+        }
+      }
+    }
+    if (errors.length > 0) {
+      sDel.stop(
+        pc4.yellow(
+          `Completed with errors. Removed: ${removedCount}, Not Found: ${notFoundCount}, Errors: ${errors.length}`
+        )
+      );
+      console.error(pc4.red("\nErrors encountered:"));
+      for (const e of errors) {
+        console.error(pc4.red(`- ${e}`));
+      }
+    } else {
+      sDel.stop(
+        pc4.green(
+          `Successfully removed ${removedCount} items. (${notFoundCount} not found)`
+        )
+      );
+    }
+    if (isSingleShot) break;
+    currentType = void 0;
+  }
+  if (!options?.skipIntro) {
+    outro4("Done!");
+  }
+}
+
+// bin/cli.ts
+var program = new Command();
+program.name("ai-agent").description("CLI to manage AI agents, skills, and workflows").version("1.4.0");
+async function interactiveMain() {
+  intro5(pc5.bgCyan(pc5.black(" AI Manager ")));
+  while (true) {
+    const action = await select5({
+      message: "What would you like to do?",
+      options: [
+        { label: "Add Item (Install)", value: "add" },
+        { label: "List Items", value: "list" },
+        { label: "Import from GitHub", value: "import" },
+        { label: "Remove Items", value: "remove" },
+        { label: "Exit", value: "exit" }
+      ]
+    });
+    if (isCancel5(action) || action === "exit") {
+      break;
+    }
+    switch (action) {
+      case "add":
+        await add(void 0, void 0, { skipIntro: true });
+        break;
+      case "list":
+        await list(void 0, { skipIntro: true });
+        break;
+      case "import":
+        await importItem(void 0, void 0, { skipIntro: true });
+        break;
+      case "remove":
+        await remove(void 0, { skipIntro: true });
+        break;
+    }
+  }
+  outro5("Goodbye!");
+}
+program.command("list [type]").description("List available items (skills, agents, workflows)").option("-l, --local", "List installed items locally").action(list);
+program.command("add [type] [url]").description(
+  "Add an item (skill, agent, workflow) to platforms (Interactive or from GitHub URL)"
+).action(add);
+program.command("import [type] [url]").description("Import an item from GitHub to the repo").action(async (type, url) => {
+  await importItem(type || "", url || "");
+});
+program.command("remove [type]").description("Remove locally installed items (skills, agents, workflows)").action(async (type) => {
+  await remove(type || "");
+});
+if (process.argv.length <= 2) {
+  await interactiveMain();
+} else {
+  await program.parseAsync();
+}