@kurokeita/add-skill 1.6.0 → 1.8.0

package/dist/bin/cli.js

@@ -1,29 +1,694 @@
 #!/usr/bin/env node
+
+// bin/cli.ts
 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);
+
+// src/commands/add.ts
+import os3 from "node:os";
+import path3 from "node:path";
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  multiselect,
+  note,
+  outro,
+  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 = {
+  antigravity: path2.join(os2.homedir(), ".gemini/antigravity/global_agents"),
+  copilot: path2.join(os2.homedir(), ".copilot/agents"),
+  gemini: path2.join(os2.homedir(), ".gemini/agents"),
+  windsurf: path2.join(os2.homedir(), ".codeium/windsurf/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/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/commands/add.ts
+function getPlatformOptions(type) {
+  const paths = getTargetPaths(type);
+  return Object.entries(paths).map(([platform, pathStr]) => ({
+    label: PLATFORM_LABELS[platform],
+    value: platform,
+    hint: pathStr.replace(os3.homedir(), "~")
+  }));
+}
+async function installItem(itemName, overwrite, sourcePath, targetBaseDir) {
+  const targetPath = path3.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) {
+  intro(pc.bgCyan(pc.black(` AI Manager : Add ${type} `)));
+  const normalizedType = type.toLowerCase().endsWith("s") ? type.slice(0, -1) : type;
+  if (!TYPE_DIRS[normalizedType]) {
+    cancel(`Unknown type: ${type}. Supported: skill, agent, workflow`);
+    process.exit(1);
+  }
+  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);
+      }
+      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) {
+        cancel(`No ${normalizedType}s found in directory.`);
+        process.exit(0);
+      }
+      const items = await multiselect({
+        message: `Select ${normalizedType}s to install:`,
+        options: availableItems,
+        required: true
+      });
+      if (isCancel(items)) {
+        cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      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);
+    }
+    const platforms = await multiselect({
+      message: "Select target platforms:",
+      options: currentPlatformOptions,
+      required: true
+    });
+    if (isCancel(platforms)) {
+      console.log("Cleaning up...");
+      if (tempDir) await fs2.remove(tempDir);
+      cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const selectedPlatforms = platforms;
+    const existingItems = [];
+    for (const platform of selectedPlatforms) {
+      const targetBase = supportedPaths[platform];
+      if (!targetBase) continue;
+      for (const item of selectedItems) {
+        const targetPath = path3.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);
+        cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      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 {
+          if (url && tempDir) {
+          }
+          let currentSourcePath;
+          if (url && tempDir) {
+            const potentialFile = path3.join(tempDir, item);
+            if (await fs2.pathExists(potentialFile) && (await fs2.stat(potentialFile)).isFile()) {
+              currentSourcePath = potentialFile;
+            } else {
+              currentSourcePath = tempDir;
+            }
+          } else {
+            const src = path3.join(TYPE_DIRS[normalizedType], item);
+            if ((await fs2.stat(src)).isFile()) {
+              currentSourcePath = src;
+            } else {
+              currentSourcePath = src;
+            }
+          }
+          let targetItemName = item;
+          if (platform === "windsurf" && normalizedType === "agent") {
+            targetItemName = path3.join(path3.parse(item).name, "AGENTS.md");
+          }
+          if (platform === "gemini" && normalizedType === "workflow" && currentSourcePath.endsWith(".md")) {
+            const targetPath = path3.join(
+              targetBase,
+              item.replace(/\.md$/, ".toml")
+            );
+            if (!overwrite && await fs2.pathExists(targetPath)) {
+              skippedCount++;
+            } else {
+              const content = await fs2.readFile(currentSourcePath, "utf-8");
+              const tomlContent = convertToGeminiCommandTOML(content);
+              await fs2.ensureDir(targetBase);
+              await fs2.writeFile(targetPath, tomlContent);
+              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)`
+        )
+      );
+    }
+    outro("You're all set!");
+  } catch (error) {
+    if (tempDir) await fs2.remove(tempDir);
+    cancel(`An error occurred: ${error}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/import.ts
+import path4 from "node:path";
+import {
+  cancel as cancel2,
+  confirm as confirm2,
+  intro as intro2,
+  isCancel as isCancel2,
+  outro as outro2,
+  spinner as spinner2
+} from "@clack/prompts";
+import fs3 from "fs-extra";
+import pc2 from "picocolors";
+async function importItem(type, url) {
+  intro2(pc2.bgCyan(pc2.black(` AI Manager : Import ${type} `)));
+  const normalizedType = type.toLowerCase().endsWith("s") ? type.slice(0, -1) : type;
+  const targetBaseDir = TYPE_DIRS[normalizedType];
+  if (!targetBaseDir) {
+    cancel2(`Unknown type: ${type}. Supported: skill, agent, workflow`);
+    process.exit(1);
+  }
+  if (!url) {
+    cancel2("GitHub URL is required.");
+    process.exit(1);
+  }
+  let tempDir = null;
+  try {
+    const s = spinner2();
+    s.start(`Fetching ${normalizedType} from GitHub...`);
+    let itemName = "";
+    let isFile = false;
+    try {
+      const result = await fetchSkillFromGitHub(url);
+      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 : path4.join(targetBaseDir, itemName);
+    if (shouldFlatten) {
+      const srcFiles = await fs3.readdir(tempDir);
+      const conflicts = [];
+      for (const file of srcFiles) {
+        if (await fs3.pathExists(path4.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) {
+          if (tempDir) await fs3.remove(tempDir);
+          cancel2("Operation cancelled.");
+          process.exit(0);
+        }
+      }
+    } 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) {
+        if (tempDir) await fs3.remove(tempDir);
+        cancel2("Operation cancelled.");
+        process.exit(0);
+      }
+    }
+    s.start(`Importing ${itemName} to ${targetBaseDir}...`);
+    await fs3.ensureDir(targetBaseDir);
+    if (isFile) {
+      await fs3.copy(path4.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}!`));
+    if (tempDir) {
+      await fs3.remove(tempDir);
+    }
+    outro2(`${normalizedType} available at: ${targetPath}`);
+  } catch (error) {
+    if (tempDir) await fs3.remove(tempDir);
+    cancel2(`An error occurred: ${error}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+import fs4 from "fs-extra";
+import pc3 from "picocolors";
+async function list(type, options) {
+  try {
+    const typesToList = type ? [type.toLowerCase()] : ["skill", "agent", "workflow"];
+    for (const t of typesToList) {
+      const normalizedType = t.endsWith("s") ? t.slice(0, -1) : t;
+      if (options?.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() || // For local items, agents/workflows might be directories OR .md files depending on how they were installed/flattened.
+              // Usually flattened -> directory (if unpacked) or file (if generic).
+              // Existing add logic:
+              // Agents/Workflows can be flattened (unpacked to base) or not.
+              // If flattened, they are files in the base dir? No, unpacked to base means they are files/dirs IN the base dir.
+              // Wait, if I import "agent-a" (dir) and flatten, it copies contents of agent-a to agents/.
+              // So "agents/skill.md" might exist.
+              // The user requirement says "list all installed agents/skills/workflows".
+              // In local global_skills (antigravity), they are directories.
+              // In local global_agents, they might be directories or .md files.
+              // Let's list directories and .md files.
+              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]) {
+          if (type) {
+            console.error(
+              pc3.red(
+                `Unknown type: ${type}. Supported types: skill, agent, workflow`
+              )
+            );
+          }
+          continue;
+        }
+        const dirPath = TYPE_DIRS[normalizedType];
+        if (!await fs4.pathExists(dirPath)) {
+          if (type) {
+            console.log(pc3.yellow(`No ${t} directory found at: ${dirPath}`));
+          }
+          continue;
+        }
+        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 if (type) {
+          console.log(pc3.dim(`No ${normalizedType}s found.`));
+        }
+      }
+    }
+  } catch (error) {
+    console.error(pc3.red("Error listing items:"), error);
+  }
+}
+
+// src/commands/remove.ts
+import path5 from "node:path";
+import {
+  cancel as cancel3,
+  confirm as confirm3,
+  intro as intro3,
+  isCancel as isCancel3,
+  multiselect as multiselect2,
+  outro as outro3,
+  spinner as spinner3
+} from "@clack/prompts";
+import fs5 from "fs-extra";
+import pc4 from "picocolors";
+async function remove(type) {
+  intro3(pc4.bgCyan(pc4.black(` AI Manager : Remove ${type} `)));
+  const normalizedType = type.toLowerCase().endsWith("s") ? type.slice(0, -1) : type;
+  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) {
+    cancel3(`No installed ${normalizedType}s found.`);
+    process.exit(0);
+  }
+  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 (isCancel3(itemSelections)) {
+    cancel3("Operation cancelled.");
+    process.exit(0);
+  }
+  const selectedItems = itemSelections;
+  const platformOptions = Object.entries(targetPaths).map(([platform]) => ({
+    label: PLATFORM_LABELS[platform],
+    value: platform
+  }));
+  const platformSelections = await multiselect2({
+    message: "Select platforms to remove from:",
+    options: platformOptions,
+    required: true
+  });
+  if (isCancel3(platformSelections)) {
+    cancel3("Operation cancelled.");
+    process.exit(0);
+  }
+  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 (isCancel3(confirmDelete) || !confirmDelete) {
+    cancel3("Operation cancelled.");
+    process.exit(0);
+  }
+  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 = path5.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)`
+      )
+    );
+  }
+  outro3("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");
+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();