@kurokeita/add-skill 1.8.0 → 1.10.0

package/dist/bin/cli.js

@@ -1,11 +1,13 @@
 #!/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 pc5 from "picocolors";
 
 // src/commands/add.ts
 import os3 from "node:os";
-import path3 from "node:path";
+import path5 from "node:path";
 import {
   cancel,
   confirm,
@@ -14,9 +16,10 @@ import {
   multiselect,
   note,
   outro,
+  select,
   spinner
 } from "@clack/prompts";
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 import pc from "picocolors";
 
 // src/utils/github.ts
@@ -103,24 +106,26 @@ var __dirname = path2.dirname(__filename);
 var PROJECT_ROOT = path2.resolve(__dirname, "../..");
 var PLATFORM_LABELS = {
   antigravity: "Antigravity",
+  codex: "Codex",
   gemini: "Gemini CLI",
   copilot: "GitHub Copilot",
   windsurf: "Windsurf"
 };
 var PLATFORM_PATHS_SKILLS = {
   antigravity: path2.join(os2.homedir(), ".gemini/antigravity/global_skills"),
+  codex: path2.join(os2.homedir(), ".codex/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"),
+  codex: path2.join(os2.homedir(), ".codex/skills"),
   copilot: path2.join(os2.homedir(), ".copilot/agents"),
-  gemini: path2.join(os2.homedir(), ".gemini/agents"),
-  windsurf: path2.join(os2.homedir(), ".codeium/windsurf/agents")
+  gemini: path2.join(os2.homedir(), ".gemini/agents")
 };
 var PLATFORM_PATHS_WORKFLOWS = {
   antigravity: path2.join(os2.homedir(), ".gemini/antigravity/global_workflows"),
+  codex: path2.join(os2.homedir(), ".codex/skills"),
   copilot: path2.join(os2.homedir(), ".copilot/prompts"),
   gemini: path2.join(os2.homedir(), ".gemini/commands"),
   windsurf: path2.join(os2.homedir(), ".codeium/windsurf/global_workflows")
@@ -141,6 +146,188 @@ function getTargetPaths(type) {
   }
 }
 
+// src/utils/platforms/antigravity.ts
+var AntigravityHandler = class {
+  platform = "antigravity";
+  getTargetFileName(itemName, _) {
+    return itemName;
+  }
+  transform(content, _, __) {
+    return content;
+  }
+};
+
+// src/utils/platforms/codex.ts
+import path3 from "node:path";
+import fs2 from "fs-extra";
+import yaml from "js-yaml";
+var frontmatterRegex = /^---\n([\s\S]*?)\n---/;
+var CODEX_TYPE_FIELD = "x-ai-agents-type";
+function extractTitle(body) {
+  const match = body.match(/^#\s+(.+)$/m);
+  return match?.[1]?.trim();
+}
+function buildDescription(type, itemName, title) {
+  const subject = title || itemName;
+  if (type === "agent") {
+    return `This skill should be used when Codex needs to follow the ${subject} agent instructions.`;
+  }
+  if (type === "workflow") {
+    return `This skill should be used when Codex needs to follow the ${subject} workflow instructions.`;
+  }
+  return `This skill should be used when Codex needs the ${subject} skill.`;
+}
+function toYamlFrontmatter(name, description, extraFields = {}) {
+  const normalizedName = name.replace(/\n+/g, " ").trim();
+  const normalizedDescription = description.replace(/\n+/g, " ").trim();
+  return yaml.dump(
+    {
+      name: normalizedName,
+      description: normalizedDescription,
+      ...extraFields
+    },
+    { lineWidth: -1 }
+  ).trimEnd();
+}
+function parseCodexType(content) {
+  const match = content.match(frontmatterRegex);
+  if (!match) return "skill";
+  try {
+    const parsed = yaml.load(match[1]);
+    if (parsed && typeof parsed === "object") {
+      const type = parsed[CODEX_TYPE_FIELD];
+      if (type === "agent" || type === "workflow" || type === "skill") {
+        return type;
+      }
+    }
+  } catch {
+    return "skill";
+  }
+  return "skill";
+}
+async function codexEntryMatchesType(basePath, entry, requestedType) {
+  let targetPath = null;
+  if (entry.isDirectory()) {
+    targetPath = path3.join(basePath, entry.name, "SKILL.md");
+  } else if (entry.isFile() && entry.name.endsWith(".md")) {
+    targetPath = path3.join(basePath, entry.name);
+  }
+  if (!targetPath) return false;
+  try {
+    const content = await fs2.readFile(targetPath, "utf-8");
+    return parseCodexType(content) === requestedType;
+  } catch {
+    return false;
+  }
+}
+var CodexHandler = class {
+  platform = "codex";
+  getTargetFileName(itemName, type) {
+    if (type === "agent" || type === "workflow") {
+      return path3.join(path3.parse(itemName).name, "SKILL.md");
+    }
+    return itemName;
+  }
+  transform(content, type, itemName) {
+    if (type === "skill") return content;
+    if (type !== "agent" && type !== "workflow") return content;
+    let name = itemName;
+    let description = "";
+    let body = content.trim();
+    const match = content.match(frontmatterRegex);
+    if (match) {
+      body = content.replace(frontmatterRegex, "").trim();
+      try {
+        const parsed = yaml.load(match[1]);
+        if (parsed && typeof parsed === "object") {
+          const frontmatter = parsed;
+          if (typeof frontmatter.name === "string" && frontmatter.name.trim()) {
+            name = frontmatter.name.trim();
+          }
+          if (typeof frontmatter.description === "string" && frontmatter.description.trim()) {
+            description = frontmatter.description.trim();
+          }
+        }
+      } catch {
+        name = itemName;
+        description = "";
+      }
+    }
+    if (!description) {
+      description = buildDescription(type, itemName, extractTitle(body));
+    }
+    const yamlStr = toYamlFrontmatter(name, description, {
+      [CODEX_TYPE_FIELD]: type
+    });
+    return `---
+${yamlStr}
+---
+
+${body}`;
+  }
+};
+
+// src/utils/platforms/copilot.ts
+import yaml2 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 frontmatterRegex2 = /^---\n([\s\S]*?)\n---/;
+    const match = content.match(frontmatterRegex2);
+    let frontmatter = {
+      name: itemName,
+      description: "",
+      target: "github-copilot",
+      tools: ["edit", "terminal", "ls", "grep_search", "githubRepo"]
+    };
+    let body = content;
+    if (match) {
+      try {
+        const parsed = yaml2.load(match[1]);
+        frontmatter = { ...frontmatter, ...parsed };
+        frontmatter.target = "github-copilot";
+        frontmatter.tools = [
+          "edit",
+          "terminal",
+          "ls",
+          "grep_search",
+          "githubRepo"
+        ];
+        body = content.replace(frontmatterRegex2, "").trim();
+      } catch (_) {
+      }
+    }
+    const yamlStr = yaml2.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 yaml3 from "js-yaml";
+
 // src/utils/toml.ts
 function convertToGeminiCommandTOML(markdownContent) {
   const lines = markdownContent.split("\n");
@@ -168,243 +355,403 @@ ${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 frontmatterRegex2 = /^---\n([\s\S]*?)\n---/;
+      const match = content.match(frontmatterRegex2);
+      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 = yaml3.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(frontmatterRegex2, "").trim();
+        } catch (_) {
+        }
+      }
+      const yamlStr = yaml3.dump(frontmatter);
+      return `---
+${yamlStr}---
+
+${body}`;
+    }
+    return content;
+  }
+};
+
+// src/utils/platforms/windsurf.ts
+import path4 from "node:path";
+var WindsurfHandler = class {
+  platform = "windsurf";
+  getTargetFileName(itemName, type) {
+    if (type === "agent") {
+      return path4.join(path4.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 CodexHandler());
+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).map(([platform, pathStr]) => ({
+  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 = path3.join(targetBaseDir, itemName);
-  if (!await fs2.pathExists(sourcePath)) {
+  const targetPath = path5.join(targetBaseDir, itemName);
+  if (!await fs3.pathExists(sourcePath)) {
     throw new Error(`Item '${itemName}' not found at ${sourcePath}`);
   }
-  if (!overwrite && await fs2.pathExists(targetPath)) {
+  if (!overwrite && await fs3.pathExists(targetPath)) {
     return false;
   }
-  await fs2.ensureDir(targetBaseDir);
-  await fs2.copy(sourcePath, targetPath, { overwrite });
+  await fs3.ensureDir(targetBaseDir);
+  await fs3.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);
+async function add(type, url, options) {
+  if (!options?.skipIntro) {
+    intro(pc.bgCyan(pc.black(" AI Manager : Add ")));
   }
-  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
+  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(items)) {
-        cancel("Operation cancelled.");
-        process.exit(0);
+      if (isCancel(selectedType) || selectedType === "exit") {
+        break;
       }
-      selectedItems = items;
+      currentType = selectedType;
     }
-    const supportedPaths = getTargetPaths(normalizedType);
-    const currentPlatformOptions = getPlatformOptions(normalizedType);
-    if (currentPlatformOptions.length === 0) {
-      cancel(`No supported platforms found for type '${normalizedType}'.`);
+    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;
     }
-    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 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 fs3.pathExists(sourceDir)) {
+          cancel(`${normalizedType} directory not found!`);
+          process.exit(1);
+          return;
+        }
+        const entries = await fs3.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;
       }
-    }
-    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
+      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(shouldOverwrite)) {
-        if (tempDir) await fs2.remove(tempDir);
-        cancel("Operation cancelled.");
-        process.exit(0);
+      if (isCancel(platforms)) {
+        if (tempDir) await fs3.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 {
-          if (url && tempDir) {
+      const selectedPlatforms = platforms;
+      const existingItems = [];
+      for (const platform of selectedPlatforms) {
+        const targetBase = supportedPaths[platform];
+        if (!targetBase) continue;
+        const handler = getHandler(platform);
+        for (const item of selectedItems) {
+          const targetItemName = handler.getTargetFileName(item, normalizedType);
+          const targetPath = path5.join(targetBase, targetItemName);
+          if (await fs3.pathExists(targetPath)) {
+            existingItems.push({ item, platform });
           }
-          let currentSourcePath;
-          if (url && tempDir) {
-            const potentialFile = path3.join(tempDir, item);
-            if (await fs2.pathExists(potentialFile) && (await fs2.stat(potentialFile)).isFile()) {
-              currentSourcePath = potentialFile;
+        }
+      }
+      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 fs3.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 = path5.join(tempDir, item);
+              if (await fs3.pathExists(potentialFile) && (await fs3.stat(potentialFile)).isFile()) {
+                currentSourcePath = potentialFile;
+              } else {
+                currentSourcePath = tempDir;
+              }
             } else {
-              currentSourcePath = tempDir;
+              const src = path5.join(TYPE_DIRS[normalizedType], item);
+              if ((await fs3.stat(src)).isFile()) {
+                currentSourcePath = src;
+              } else {
+                currentSourcePath = src;
+              }
             }
-          } else {
-            const src = path3.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 = path5.join(targetBase, targetItemName);
+              if (!overwrite && await fs3.pathExists(targetPath)) {
+                skippedCount++;
+              } else {
+                let content = await fs3.readFile(currentSourcePath, "utf-8");
+                content = handler.transform(
+                  content,
+                  normalizedType,
+                  path5.parse(item).name
+                );
+                await fs3.ensureDir(path5.dirname(targetPath));
+                await fs3.writeFile(targetPath, content);
+                installedCount++;
+              }
+              continue;
             }
-          }
-          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")
+            const installed = await installItem(
+              targetItemName,
+              overwrite,
+              currentSourcePath,
+              targetBase
             );
-            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);
+            if (installed) {
               installedCount++;
+            } else {
+              skippedCount++;
             }
-            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}`);
           }
-        } 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}`));
+      if (tempDir) {
+        await fs3.remove(tempDir);
       }
-    } else {
-      s.stop(
-        pc.green(
-          `Successfully installed ${installedCount} ${normalizedType}s. (${skippedCount} skipped)`
-        )
-      );
+      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 fs3.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!");
-  } 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 path6 from "node:path";
 import {
   cancel as cancel2,
   confirm as confirm2,
   intro as intro2,
   isCancel as isCancel2,
   outro as outro2,
-  spinner as spinner2
+  select as select2,
+  spinner as spinner2,
+  text
 } from "@clack/prompts";
-import fs3 from "fs-extra";
+import fs4 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;
+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: ${type}. Supported: skill, agent, workflow`);
+    cancel2(`Unknown type: ${currentType}. Supported: skill, agent, workflow`);
     process.exit(1);
+    return;
   }
-  if (!url) {
-    cancel2("GitHub URL is required.");
-    process.exit(1);
+  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 {
@@ -413,7 +760,7 @@ async function importItem(type, url) {
     let itemName = "";
     let isFile = false;
     try {
-      const result = await fetchSkillFromGitHub(url);
+      const result = await fetchSkillFromGitHub(currentUrl);
       tempDir = result.tempDir;
       if (!tempDir) throw new Error("Failed to create temp directory");
       itemName = result.skillName;
@@ -424,12 +771,12 @@ async function importItem(type, url) {
       throw e;
     }
     const shouldFlatten = (normalizedType === "agent" || normalizedType === "workflow") && !isFile;
-    const targetPath = shouldFlatten ? targetBaseDir : path4.join(targetBaseDir, itemName);
+    const targetPath = shouldFlatten ? targetBaseDir : path6.join(targetBaseDir, itemName);
     if (shouldFlatten) {
-      const srcFiles = await fs3.readdir(tempDir);
+      const srcFiles = await fs4.readdir(tempDir);
       const conflicts = [];
       for (const file of srcFiles) {
-        if (await fs3.pathExists(path4.join(targetBaseDir, file))) {
+        if (await fs4.pathExists(path6.join(targetBaseDir, file))) {
           conflicts.push(file);
         }
       }
@@ -443,252 +790,370 @@ async function importItem(type, url) {
           initialValue: false
         });
         if (isCancel2(shouldOverwrite) || !shouldOverwrite) {
-          if (tempDir) await fs3.remove(tempDir);
-          cancel2("Operation cancelled.");
-          process.exit(0);
+          await fs4.remove(tempDir);
+          return;
         }
       }
-    } else if (await fs3.pathExists(targetPath)) {
+    } else if (await fs4.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);
+        await fs4.remove(tempDir);
+        return;
       }
     }
     s.start(`Importing ${itemName} to ${targetBaseDir}...`);
-    await fs3.ensureDir(targetBaseDir);
+    await fs4.ensureDir(targetBaseDir);
     if (isFile) {
-      await fs3.copy(path4.join(tempDir, itemName), targetPath, {
+      await fs4.copy(path6.join(tempDir, itemName), targetPath, {
         overwrite: true
       });
     } else {
       if (shouldFlatten) {
-        await fs3.copy(tempDir, targetBaseDir, { overwrite: true });
+        await fs4.copy(tempDir, targetBaseDir, { overwrite: true });
       } else {
-        await fs3.copy(tempDir, targetPath, { overwrite: true });
+        await fs4.copy(tempDir, targetPath, { overwrite: true });
       }
     }
     s.stop(pc2.green(`Successfully imported ${itemName}!`));
-    if (tempDir) {
-      await fs3.remove(tempDir);
+    await fs4.remove(tempDir);
+    if (!options?.skipIntro) {
+      outro2(`${normalizedType} available at: ${targetPath}`);
     }
-    outro2(`${normalizedType} available at: ${targetPath}`);
   } catch (error) {
-    if (tempDir) await fs3.remove(tempDir);
+    if (tempDir) await fs4.remove(tempDir);
     cancel2(`An error occurred: ${error}`);
     process.exit(1);
+    return;
   }
 }
 
 // src/commands/list.ts
-import fs4 from "fs-extra";
+import { intro as intro3, isCancel as isCancel3, outro as outro3, select as select3 } from "@clack/prompts";
+import fs5 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}`);
-              }
+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 fs5.pathExists(fullPath)) {
+        const entries = await fs5.readdir(fullPath, {
+          withFileTypes: true
+        });
+        const items = [];
+        for (const entry of entries) {
+          if (platform === "codex") {
+            if (await codexEntryMatchesType(fullPath, entry, normalizedType)) {
+              items.push(entry.name);
             }
+            continue;
           }
-        }
-        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}`));
+          if (entry.isDirectory() || entry.isFile() && entry.name.endsWith(".md")) {
+            items.push(entry.name);
           }
-          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();
+        items.sort();
         if (items.length > 0) {
-          console.log(pc3.bold(pc3.blue(`Available ${normalizedType}s:`)));
+          foundAny = true;
+          console.log(pc3.cyan(`  ${platform}:`));
           for (const item of items) {
-            console.log(`- ${item}`);
+            console.log(`    - ${item}`);
           }
-          console.log(pc3.dim(`Total: ${items.length} ${normalizedType}s
+        }
+      }
+    }
+    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 fs5.pathExists(dirPath)) {
+      console.log(
+        pc3.yellow(`No ${normalizedType} directory found at: ${dirPath}`)
+      );
+      return;
+    }
+    const entries = await fs5.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.`));
+    } 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 path5 from "node:path";
+import path7 from "node:path";
 import {
-  cancel as cancel3,
   confirm as confirm3,
-  intro as intro3,
-  isCancel as isCancel3,
+  intro as intro4,
+  isCancel as isCancel4,
   multiselect as multiselect2,
-  outro as outro3,
+  note as note2,
+  outro as outro4,
+  select as select4,
   spinner as spinner3
 } from "@clack/prompts";
-import fs5 from "fs-extra";
+import fs6 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
+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" }
+        ]
       });
-      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);
+      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 [platform, pathStr] of Object.entries(targetPaths)) {
+      if (await fs6.pathExists(pathStr)) {
+        const entries = await fs6.readdir(pathStr, {
+          withFileTypes: true
+        });
+        for (const entry of entries) {
+          if (platform === "codex") {
+            if (await codexEntryMatchesType(
+              pathStr,
+              entry,
+              normalizedType
+            )) {
+              uniqueItems.add(entry.name);
+            }
+            continue;
+          }
+          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}`);
+    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 = path7.join(targetBase, item);
+        if (await fs6.pathExists(targetPath)) {
+          sDel.message(`Removing ${pc4.bold(item)} from ${pc4.cyan(platform)}...`);
+          try {
+            await fs6.remove(targetPath);
+            removedCount++;
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`${item} (${platform}): ${msg}`);
+          }
+        } else {
+          notFoundCount++;
         }
-      } 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}`));
+    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)`
+        )
+      );
     }
-  } else {
-    sDel.stop(
-      pc4.green(
-        `Successfully removed ${removedCount} items. (${notFoundCount} not found)`
-      )
-    );
+    if (isSingleShot) break;
+    currentType = void 0;
+  }
+  if (!options?.skipIntro) {
+    outro4("Done!");
   }
-  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");
+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(
+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();
+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();
+}