@toolr/seedr 0.1.71 → 0.1.73

package/dist/cli.js

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
 import {
-  AI_TOOLS,
-  ALL_TOOLS,
+  ALL_AGENTS,
+  CODING_AGENTS,
+  brand,
+  cancelled,
+  confirm,
   ensureDir,
+  error,
   exists,
   fetchItemToDestination,
+  getAgentPath,
   getAgentsPath,
   getContentPath,
   getInstalledSkills,
@@ -13,124 +18,34 @@ import {
   getItemSourcePath,
   getMcpPath,
   getSettingsPath,
-  getToolPath,
+  info,
   installDirectory,
   installFile,
+  intro,
   listItems,
-  parseToolsArg,
+  outro,
+  p,
+  parseAgentsArg,
+  printLogo,
   removeFile,
   searchItems,
+  selectAgents,
+  selectMethod,
+  selectScope,
+  selectSkill,
   skillHandler,
+  step,
+  success,
+  warn,
   writeTextFile
-} from "./chunk-DI5Z3O3G.js";
+} from "./chunk-OYOVC7VN.js";
 
 // src/cli.ts
 import { Command as Command5 } from "commander";
-import chalk12 from "chalk";
 
 // src/commands/add.ts
 import { Command } from "commander";
-import chalk8 from "chalk";
-
-// src/utils/ui.ts
-import * as p from "@clack/prompts";
-import chalk from "chalk";
-var LOGO = `
-\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557
-\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
-\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
-\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
-\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D`;
-var URLS = {
-  toolr: "https://toolr.dev",
-  seedr: "https://seedr.toolr.dev"
-};
-function printLogo() {
-  console.log(chalk.cyan(LOGO));
-  console.log(chalk.gray(`  ${URLS.seedr}  \xB7  ${URLS.toolr}`));
-  console.log();
-}
-async function selectSkill(items) {
-  const result = await p.select({
-    message: "Select a skill to install",
-    options: items.map((item) => ({
-      label: item.name,
-      value: item,
-      hint: item.description
-    }))
-  });
-  return result;
-}
-async function selectTools(compatible) {
-  const allOption = await p.select({
-    message: "Which AI tools do you want to install for?",
-    options: [
-      { label: `All (${compatible.length} agents)`, value: "all" },
-      { label: "Select specific tools...", value: "select" }
-    ]
-  });
-  if (p.isCancel(allOption)) return allOption;
-  if (allOption === "all") return compatible;
-  const result = await p.multiselect({
-    message: "Select tools",
-    options: compatible.map((tool) => ({
-      label: AI_TOOLS[tool].name,
-      value: tool,
-      hint: AI_TOOLS[tool].projectRoot
-    })),
-    initialValues: ["claude"],
-    required: true
-  });
-  return result;
-}
-async function selectScope(includeLocal = false) {
-  const options = [
-    { label: "Project", value: "project", hint: includeLocal ? "current directory, settings.json" : "current directory" },
-    { label: "User", value: "user", hint: "home directory" },
-    ...includeLocal ? [{ label: "Local", value: "local", hint: "current directory, settings.local.json" }] : []
-  ];
-  const result = await p.select({ message: "Installation scope", options });
-  return result;
-}
-async function selectMethod(symlinkPath) {
-  const result = await p.select({
-    message: "Installation method",
-    options: [
-      { label: "Symlink", value: "symlink", hint: `shared at ${symlinkPath}` },
-      { label: "Copy", value: "copy", hint: "standalone copy per tool" }
-    ]
-  });
-  return result;
-}
-async function confirm2(message) {
-  return p.confirm({ message });
-}
-function cancelled() {
-  p.cancel("Operation cancelled");
-  process.exit(0);
-}
-function intro2(message) {
-  p.intro(chalk.bgCyan.black(` ${message} `));
-}
-function outro2(message) {
-  p.outro(chalk.green(message));
-}
-function step(message) {
-  p.log.step(message);
-}
-function info(message) {
-  p.log.info(message);
-}
-function success(message) {
-  p.log.success(message);
-}
-function warn(message) {
-  p.log.warn(message);
-}
-function error(message) {
-  p.log.error(message);
-}
+import chalk7 from "chalk";
 
 // src/handlers/registry.ts
 var handlers = /* @__PURE__ */ new Map();
@@ -142,10 +57,10 @@ function getHandler(type) {
 }
 
 // src/utils/errors.ts
-import chalk2 from "chalk";
+import chalk from "chalk";
 function handleCommandError(error2) {
   console.error(
-    chalk2.red(`Error: ${error2 instanceof Error ? error2.message : "Unknown error"}`)
+    chalk.red(`Error: ${error2 instanceof Error ? error2.message : "Unknown error"}`)
   );
   process.exit(1);
 }
@@ -162,9 +77,9 @@ function trackInstalls(slug, type, results, scope) {
       body: JSON.stringify({
         slug,
         type,
-        tool: result.tool,
+        agent: result.agent,
         scope,
-        version: "0.1.71"
+        version: "0.1.73"
       }),
       signal: AbortSignal.timeout(4e3)
     }).catch(() => {
@@ -173,7 +88,7 @@ function trackInstalls(slug, type, results, scope) {
 }
 
 // src/config/compatibility.ts
-var TOOL_COMPATIBILITY = {
+var AGENT_COMPATIBILITY = {
   skill: ["claude", "copilot", "gemini", "codex", "opencode"],
   command: ["claude"],
   agent: ["claude"],
@@ -182,24 +97,24 @@ var TOOL_COMPATIBILITY = {
   settings: ["claude"],
   mcp: ["claude", "copilot", "gemini", "codex", "opencode"]
 };
-function filterCompatibleTools(type, tools) {
-  const compatible = TOOL_COMPATIBILITY[type];
-  return tools.filter((t) => compatible.includes(t));
+function filterCompatibleAgents(type, agents) {
+  const compatible = AGENT_COMPATIBILITY[type];
+  return agents.filter((a) => compatible.includes(a));
 }
 
 // src/handlers/agent.ts
 import { join } from "path";
 import { readdir } from "fs/promises";
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 import ora from "ora";
-async function installAgentForTool(item, tool, scope, method, cwd) {
+async function installAgentForCodingAgent(item, agent, scope, method, cwd) {
   const spinner = ora(
-    `Installing ${item.name} for ${AI_TOOLS[tool].name}...`
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
   ).start();
   try {
-    const destDir = getContentPath(tool, "agent", scope, cwd);
+    const destDir = getContentPath(agent, "agent", scope, cwd);
     if (!destDir) {
-      throw new Error(`${AI_TOOLS[tool].name} does not support agents`);
+      throw new Error(`${CODING_AGENTS[agent].name} does not support agents`);
     }
     const destPath = join(destDir, `${item.slug}.md`);
     const sourcePath = getItemSourcePath(item);
@@ -218,27 +133,27 @@ async function installAgentForTool(item, tool, scope, method, cwd) {
       await writeTextFile(destPath, content);
     }
     spinner.succeed(
-      chalk3.green(`Installed ${item.name} for ${AI_TOOLS[tool].name}`)
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
     );
-    return { tool, success: true, path: destPath };
+    return { agent, success: true, path: destPath };
   } catch (error2) {
     const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
     spinner.fail(
-      chalk3.red(`Failed to install for ${AI_TOOLS[tool].name}: ${errorMsg}`)
+      chalk2.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
     );
-    return { tool, success: false, path: "", error: errorMsg };
+    return { agent, success: false, path: "", error: errorMsg };
   }
 }
-async function installAgent(item, tools, scope, method, cwd = process.cwd()) {
+async function installAgent(item, agents, scope, method, cwd = process.cwd()) {
   const results = [];
-  for (const tool of tools) {
-    const result = await installAgentForTool(item, tool, scope, method, cwd);
+  for (const agent of agents) {
+    const result = await installAgentForCodingAgent(item, agent, scope, method, cwd);
     results.push(result);
   }
   return results;
 }
-async function uninstallAgent(slug, tool, scope, cwd = process.cwd()) {
-  const destDir = getContentPath(tool, "agent", scope, cwd);
+async function uninstallAgent(slug, agent, scope, cwd = process.cwd()) {
+  const destDir = getContentPath(agent, "agent", scope, cwd);
   if (!destDir) return false;
   const destPath = join(destDir, `${slug}.md`);
   if (!await exists(destPath)) {
@@ -246,8 +161,8 @@ async function uninstallAgent(slug, tool, scope, cwd = process.cwd()) {
   }
   return removeFile(destPath);
 }
-async function getInstalledAgents(tool, scope, cwd = process.cwd()) {
-  const destDir = getContentPath(tool, "agent", scope, cwd);
+async function getInstalledAgents(agent, scope, cwd = process.cwd()) {
+  const destDir = getContentPath(agent, "agent", scope, cwd);
   if (!destDir || !await exists(destDir)) {
     return [];
   }
@@ -256,14 +171,14 @@ async function getInstalledAgents(tool, scope, cwd = process.cwd()) {
 }
 var agentHandler = {
   type: "agent",
-  async install(item, tools, scope, method, cwd) {
-    return installAgent(item, tools, scope, method, cwd);
+  async install(item, agents, scope, method, cwd) {
+    return installAgent(item, agents, scope, method, cwd);
   },
-  async uninstall(slug, tool, scope, cwd) {
-    return uninstallAgent(slug, tool, scope, cwd);
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallAgent(slug, agent, scope, cwd);
   },
-  async listInstalled(tool, scope, cwd) {
-    return getInstalledAgents(tool, scope, cwd);
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledAgents(agent, scope, cwd);
   }
 };
 
@@ -271,7 +186,7 @@ var agentHandler = {
 import { join as join2, basename } from "path";
 import { homedir } from "os";
 import { mkdir, copyFile, chmod, rm } from "fs/promises";
-import chalk4 from "chalk";
+import chalk3 from "chalk";
 import ora2 from "ora";
 
 // src/utils/json.ts
@@ -338,12 +253,12 @@ function findScriptFile(item) {
   }
   return null;
 }
-async function installHookForTool(item, tool, scope, _method, cwd) {
+async function installHookForAgent(item, agent, scope, _method, cwd) {
   const spinner = ora2(
-    `Installing ${item.name} for ${AI_TOOLS[tool].name}...`
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
   ).start();
   try {
-    if (tool !== "claude") {
+    if (agent !== "claude") {
       throw new Error("Hooks are only supported for Claude Code");
     }
     const triggers = item.contents?.triggers;
@@ -401,27 +316,27 @@ async function installHookForTool(item, tool, scope, _method, cwd) {
     }
     await writeJson(settingsPath, settings);
     spinner.succeed(
-      chalk4.green(`Installed ${item.name} for ${AI_TOOLS[tool].name}`)
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
     );
-    return { tool, success: true, path: destScriptPath };
+    return { agent, success: true, path: destScriptPath };
   } catch (error2) {
     const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
     spinner.fail(
-      chalk4.red(`Failed to install for ${AI_TOOLS[tool].name}: ${errorMsg}`)
+      chalk3.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
     );
-    return { tool, success: false, path: "", error: errorMsg };
+    return { agent, success: false, path: "", error: errorMsg };
   }
 }
-async function installHook(item, tools, scope, method, cwd = process.cwd()) {
+async function installHook(item, agents, scope, method, cwd = process.cwd()) {
   const results = [];
-  for (const tool of tools) {
-    const result = await installHookForTool(item, tool, scope, method, cwd);
+  for (const agent of agents) {
+    const result = await installHookForAgent(item, agent, scope, method, cwd);
     results.push(result);
   }
   return results;
 }
-async function uninstallHook(slug, tool, scope, cwd = process.cwd()) {
-  if (tool !== "claude") return false;
+async function uninstallHook(slug, agent, scope, cwd = process.cwd()) {
+  if (agent !== "claude") return false;
   const settingsPath = getSettingsPath(scope, cwd);
   if (!await exists(settingsPath)) return false;
   const item = await getItem(slug, "hook");
@@ -469,8 +384,8 @@ async function uninstallHook(slug, tool, scope, cwd = process.cwd()) {
   }
   return removed;
 }
-async function getInstalledHooks(tool, scope, cwd = process.cwd()) {
-  if (tool !== "claude") return [];
+async function getInstalledHooks(agent, scope, cwd = process.cwd()) {
+  if (agent !== "claude") return [];
   const settingsPath = getSettingsPath(scope, cwd);
   if (!await exists(settingsPath)) return [];
   const settings = await readJson(settingsPath);
@@ -488,19 +403,19 @@ async function getInstalledHooks(tool, scope, cwd = process.cwd()) {
 }
 var hookHandler = {
   type: "hook",
-  async install(item, tools, scope, method, cwd) {
-    return installHook(item, tools, scope, method, cwd);
+  async install(item, agents, scope, method, cwd) {
+    return installHook(item, agents, scope, method, cwd);
   },
-  async uninstall(slug, tool, scope, cwd) {
-    return uninstallHook(slug, tool, scope, cwd);
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallHook(slug, agent, scope, cwd);
   },
-  async listInstalled(tool, scope, cwd) {
-    return getInstalledHooks(tool, scope, cwd);
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledHooks(agent, scope, cwd);
   }
 };
 
 // src/handlers/mcp.ts
-import chalk5 from "chalk";
+import chalk4 from "chalk";
 import ora3 from "ora";
 function parseMcpDefinition(content) {
   try {
@@ -509,9 +424,9 @@ function parseMcpDefinition(content) {
     throw new Error("Invalid MCP definition: must be valid JSON");
   }
 }
-async function installMcpForTool(item, tool, scope, _method, cwd) {
+async function installMcpForAgent(item, agent, scope, _method, cwd) {
   const spinner = ora3(
-    `Installing ${item.name} for ${AI_TOOLS[tool].name}...`
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
   ).start();
   try {
     const content = await getItemContent(item);
@@ -522,26 +437,26 @@ async function installMcpForTool(item, tool, scope, _method, cwd) {
     config.mcpServers[mcpDef.name] = mcpDef.config;
     await writeJson(configPath, config);
     spinner.succeed(
-      chalk5.green(`Installed ${item.name} for ${AI_TOOLS[tool].name}`)
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
     );
-    return { tool, success: true, path: configPath };
+    return { agent, success: true, path: configPath };
   } catch (error2) {
     const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
     spinner.fail(
-      chalk5.red(`Failed to install for ${AI_TOOLS[tool].name}: ${errorMsg}`)
+      chalk4.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
     );
-    return { tool, success: false, path: "", error: errorMsg };
+    return { agent, success: false, path: "", error: errorMsg };
   }
 }
-async function installMcp(item, tools, scope, method, cwd = process.cwd()) {
+async function installMcp(item, agents, scope, method, cwd = process.cwd()) {
   const results = [];
-  for (const tool of tools) {
-    const result = await installMcpForTool(item, tool, scope, method, cwd);
+  for (const agent of agents) {
+    const result = await installMcpForAgent(item, agent, scope, method, cwd);
     results.push(result);
   }
   return results;
 }
-async function uninstallMcp(slug, _tool, scope, cwd = process.cwd()) {
+async function uninstallMcp(slug, _agent, scope, cwd = process.cwd()) {
   const configPath = getMcpPath(scope, cwd);
   if (!await exists(configPath)) return false;
   const config = await readJson(configPath);
@@ -552,7 +467,7 @@ async function uninstallMcp(slug, _tool, scope, cwd = process.cwd()) {
   await writeJson(configPath, config);
   return true;
 }
-async function getInstalledMcpServers(_tool, scope, cwd = process.cwd()) {
+async function getInstalledMcpServers(_agent, scope, cwd = process.cwd()) {
   const configPath = getMcpPath(scope, cwd);
   if (!await exists(configPath)) return [];
   const config = await readJson(configPath);
@@ -560,19 +475,19 @@ async function getInstalledMcpServers(_tool, scope, cwd = process.cwd()) {
 }
 var mcpHandler = {
   type: "mcp",
-  async install(item, tools, scope, method, cwd) {
-    return installMcp(item, tools, scope, method, cwd);
+  async install(item, agents, scope, method, cwd) {
+    return installMcp(item, agents, scope, method, cwd);
   },
-  async uninstall(slug, tool, scope, cwd) {
-    return uninstallMcp(slug, tool, scope, cwd);
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallMcp(slug, agent, scope, cwd);
   },
-  async listInstalled(tool, scope, cwd) {
-    return getInstalledMcpServers(tool, scope, cwd);
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledMcpServers(agent, scope, cwd);
   }
 };
 
 // src/handlers/settings.ts
-import chalk6 from "chalk";
+import chalk5 from "chalk";
 import ora4 from "ora";
 function parseSettings(content) {
   try {
@@ -581,12 +496,12 @@ function parseSettings(content) {
     throw new Error("Invalid settings: must be valid JSON");
   }
 }
-async function installSettingsForTool(item, tool, scope, _method, cwd) {
+async function installSettingsForAgent(item, agent, scope, _method, cwd) {
   const spinner = ora4(
-    `Installing ${item.name} for ${AI_TOOLS[tool].name}...`
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
   ).start();
   try {
-    if (tool !== "claude") {
+    if (agent !== "claude") {
       throw new Error("Settings are only supported for Claude Code");
     }
     const content = await getItemContent(item);
@@ -596,21 +511,21 @@ async function installSettingsForTool(item, tool, scope, _method, cwd) {
     const merged = deepMerge(existingSettings, newSettings);
     await writeJson(settingsPath, merged);
     spinner.succeed(
-      chalk6.green(`Installed ${item.name} for ${AI_TOOLS[tool].name}`)
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
     );
-    return { tool, success: true, path: settingsPath };
+    return { agent, success: true, path: settingsPath };
   } catch (error2) {
     const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
     spinner.fail(
-      chalk6.red(`Failed to install for ${AI_TOOLS[tool].name}: ${errorMsg}`)
+      chalk5.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
     );
-    return { tool, success: false, path: "", error: errorMsg };
+    return { agent, success: false, path: "", error: errorMsg };
   }
 }
-async function installSettings(item, tools, scope, method, cwd = process.cwd()) {
+async function installSettings(item, agents, scope, method, cwd = process.cwd()) {
   const results = [];
-  for (const tool of tools) {
-    const result = await installSettingsForTool(item, tool, scope, method, cwd);
+  for (const agent of agents) {
+    const result = await installSettingsForAgent(item, agent, scope, method, cwd);
     results.push(result);
   }
   return results;
@@ -642,8 +557,8 @@ function deepUnmerge(target, source) {
   }
   return { result, changed };
 }
-async function uninstallSettings(slug, tool, scope, cwd = process.cwd()) {
-  if (tool !== "claude") return false;
+async function uninstallSettings(slug, agent, scope, cwd = process.cwd()) {
+  if (agent !== "claude") return false;
   const item = await getItem(slug, "settings");
   if (!item) return false;
   let content;
@@ -662,22 +577,22 @@ async function uninstallSettings(slug, tool, scope, cwd = process.cwd()) {
   }
   return changed;
 }
-async function getInstalledSettings(tool, scope, cwd = process.cwd()) {
-  if (tool !== "claude") return [];
+async function getInstalledSettings(agent, scope, cwd = process.cwd()) {
+  if (agent !== "claude") return [];
   const settingsPath = getSettingsPath(scope, cwd);
   if (!await exists(settingsPath)) return [];
   return [];
 }
 var settingsHandler = {
   type: "settings",
-  async install(item, tools, scope, method, cwd) {
-    return installSettings(item, tools, scope, method, cwd);
+  async install(item, agents, scope, method, cwd) {
+    return installSettings(item, agents, scope, method, cwd);
   },
-  async uninstall(slug, tool, scope, cwd) {
-    return uninstallSettings(slug, tool, scope, cwd);
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallSettings(slug, agent, scope, cwd);
   },
-  async listInstalled(tool, scope, cwd) {
-    return getInstalledSettings(tool, scope, cwd);
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledSettings(agent, scope, cwd);
   }
 };
 
@@ -687,7 +602,7 @@ import { join as join3 } from "path";
 import { mkdir as mkdir2, rm as rm2 } from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import chalk7 from "chalk";
+import chalk6 from "chalk";
 import ora5 from "ora";
 var home = homedir2();
 var PLUGINS_CACHE_DIR = join3(home, ".claude/plugins/cache");
@@ -728,12 +643,12 @@ async function ensureMarketplaceRegistered(marketplace, item) {
   };
   await writeJson(KNOWN_MARKETPLACES_PATH, known);
 }
-async function installPluginForTool(item, tool, scope, method, cwd) {
+async function installPluginForAgent(item, agent, scope, method, cwd) {
   const spinner = ora5(
-    `Installing ${item.name} for ${AI_TOOLS[tool].name}...`
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
   ).start();
   try {
-    if (tool !== "claude") {
+    if (agent !== "claude") {
       throw new Error("Plugins are only supported for Claude Code");
     }
     const tmpPath = join3(PLUGINS_CACHE_DIR, ".tmp", item.slug);
@@ -779,27 +694,27 @@ async function installPluginForTool(item, tool, scope, method, cwd) {
     settings.enabledPlugins[pluginId] = true;
     await writeJson(settingsPath, settings);
     spinner.succeed(
-      chalk7.green(`Installed ${item.name} for ${AI_TOOLS[tool].name}`)
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
     );
-    return { tool, success: true, path: cachePath };
+    return { agent, success: true, path: cachePath };
   } catch (error2) {
     const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
     spinner.fail(
-      chalk7.red(`Failed to install for ${AI_TOOLS[tool].name}: ${errorMsg}`)
+      chalk6.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
     );
-    return { tool, success: false, path: "", error: errorMsg };
+    return { agent, success: false, path: "", error: errorMsg };
   }
 }
-async function installPlugin(item, tools, scope, method, cwd = process.cwd()) {
+async function installPlugin(item, agents, scope, method, cwd = process.cwd()) {
   const results = [];
-  for (const tool of tools) {
-    const result = await installPluginForTool(item, tool, scope, method, cwd);
+  for (const agent of agents) {
+    const result = await installPluginForAgent(item, agent, scope, method, cwd);
     results.push(result);
   }
   return results;
 }
-async function uninstallPlugin(slug, tool, scope, cwd = process.cwd()) {
-  if (tool !== "claude") return false;
+async function uninstallPlugin(slug, agent, scope, cwd = process.cwd()) {
+  if (agent !== "claude") return false;
   const registry = await readJson(INSTALLED_PLUGINS_PATH);
   if (!registry.plugins) return false;
   const matchingKey = Object.keys(registry.plugins).find(
@@ -824,8 +739,8 @@ async function uninstallPlugin(slug, tool, scope, cwd = process.cwd()) {
   }
   return true;
 }
-async function getInstalledPlugins(tool, scope, cwd = process.cwd()) {
-  if (tool !== "claude") return [];
+async function getInstalledPlugins(agent, scope, cwd = process.cwd()) {
+  if (agent !== "claude") return [];
   const registry = await readJson(INSTALLED_PLUGINS_PATH);
   if (!registry.plugins) return [];
   const installed = [];
@@ -842,14 +757,14 @@ async function getInstalledPlugins(tool, scope, cwd = process.cwd()) {
 }
 var pluginHandler = {
   type: "plugin",
-  async install(item, tools, scope, method, cwd) {
-    return installPlugin(item, tools, scope, method, cwd);
+  async install(item, agents, scope, method, cwd) {
+    return installPlugin(item, agents, scope, method, cwd);
   },
-  async uninstall(slug, tool, scope, cwd) {
-    return uninstallPlugin(slug, tool, scope, cwd);
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallPlugin(slug, agent, scope, cwd);
   },
-  async listInstalled(tool, scope, cwd) {
-    return getInstalledPlugins(tool, scope, cwd);
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledPlugins(agent, scope, cwd);
   }
 };
 
@@ -904,43 +819,43 @@ async function resolveItem(itemName, type) {
   }
   return selected;
 }
-function resolveTools(agentsArg, item) {
-  const typeCompatible = filterCompatibleTools(item.type, item.compatibility);
+function resolveAgents(agentsArg, item) {
+  const typeCompatible = filterCompatibleAgents(item.type, item.compatibility);
   if (!agentsArg) return [];
-  const tools = parseToolsArg(agentsArg, typeCompatible);
-  if (agentsArg === "all") return tools;
-  const incompatible = tools.filter((t) => !typeCompatible.includes(t));
+  const agents = parseAgentsArg(agentsArg, typeCompatible);
+  if (agentsArg === "all") return agents;
+  const incompatible = agents.filter((a) => !typeCompatible.includes(a));
   if (incompatible.length > 0) {
     warn(`${incompatible.join(", ")} not compatible with this ${item.type}`);
-    return tools.filter((t) => typeCompatible.includes(t));
+    return agents.filter((a) => typeCompatible.includes(a));
   }
-  return tools;
+  return agents;
 }
-function printDryRunSummary(item, tools, scope, method, cwd) {
+function printDryRunSummary(item, agents, scope, method, cwd) {
   info("Dry run - no files will be written\n");
-  console.log(chalk8.cyan("  Would install:"));
-  console.log(`    ${item.type}: ${chalk8.white(item.name)}`);
-  console.log(`    Scope: ${chalk8.white(scope)}`);
-  console.log(`    Method: ${chalk8.white(method)}`);
+  console.log(brand("  Would install:"));
+  console.log(`    ${item.type}: ${chalk7.white(item.name)}`);
+  console.log(`    Scope: ${chalk7.white(scope)}`);
+  console.log(`    Method: ${chalk7.white(method)}`);
   console.log();
   if (method === "symlink" && item.type === "skill") {
     const centralPath = getAgentsPath("skill", item.slug, cwd);
-    console.log(chalk8.cyan("  Central storage:"));
-    console.log(`    ${chalk8.gray("\u2192")} ${chalk8.gray(centralPath)}`);
+    console.log(brand("  Central storage:"));
+    console.log(`    ${chalk7.gray("\u2192")} ${chalk7.gray(centralPath)}`);
     console.log();
-    console.log(chalk8.cyan("  Symlinks from tool folders:"));
+    console.log(brand("  Symlinks from agent folders:"));
   } else {
-    console.log(chalk8.cyan("  Target locations:"));
+    console.log(brand("  Target locations:"));
   }
-  for (const tool of tools) {
-    const config = AI_TOOLS[tool];
-    const contentPath = getContentPath(tool, item.type, scope, cwd);
+  for (const agent of agents) {
+    const config = CODING_AGENTS[agent];
+    const contentPath = getContentPath(agent, item.type, scope, cwd);
     if (!contentPath) {
-      console.log(`    ${chalk8.gray("\u2192")} ${chalk8.white(config.name)}: ${chalk8.red("not supported")}`);
+      console.log(`    ${chalk7.gray("\u2192")} ${chalk7.white(config.name)}: ${chalk7.red("not supported")}`);
       continue;
     }
     const targetPath = `${contentPath}/${item.slug}`;
-    console.log(`    ${chalk8.gray("\u2192")} ${chalk8.white(config.name)}: ${chalk8.gray(targetPath)}`);
+    console.log(`    ${chalk7.gray("\u2192")} ${chalk7.white(config.name)}: ${chalk7.gray(targetPath)}`);
   }
   console.log();
 }
@@ -948,55 +863,55 @@ function printInstallSummary(results) {
   const successful = results.filter((r) => r.success);
   const failed = results.filter((r) => !r.success);
   if (successful.length > 0) {
-    success(`Installed for ${successful.length} tool(s)`);
+    success(`Installed for ${successful.length} agent(s)`);
     for (const r of successful) {
-      console.log(chalk8.gray(`    \u2192 ${r.path}`));
+      console.log(chalk7.gray(`    \u2192 ${r.path}`));
     }
   }
   if (failed.length > 0) {
-    error(`Failed for ${failed.length} tool(s)`);
+    error(`Failed for ${failed.length} agent(s)`);
     for (const r of failed) {
-      console.log(chalk8.red(`    \xD7 ${r.tool}: ${r.error}`));
+      console.log(chalk7.red(`    \xD7 ${r.agent}: ${r.error}`));
     }
     process.exit(1);
   }
 }
 var addCommand = new Command("add").description("Install a skill, agent, hook, or other configuration").argument("[name]", "Name of the item to install").option("-t, --type <type>", "Content type: skill, agent, hook, mcp, plugin, settings").option(
-  "-a, --agents <tools>",
-  "Comma-separated AI tools or 'all' (claude,copilot,gemini,codex,opencode)"
+  "-a, --agents <agents>",
+  "Comma-separated coding agents or 'all' (claude,copilot,gemini,codex,opencode)"
 ).option("-s, --scope <scope>", "Installation scope: project, user, or local").option("-m, --method <method>", "Installation method: symlink or copy").option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Overwrite existing files").option("-n, --dry-run", "Show what would be installed without making changes").action(async (name, options) => {
   try {
     printLogo();
-    intro2("Seedr");
+    intro("Seedr");
     const itemName = name;
     const contentType = options.type;
     const item = await resolveItem(itemName, contentType);
     if (!item) process.exit(1);
-    step(`Selected: ${chalk8.cyan(item.name)} ${chalk8.gray(`(${item.type})`)} ${chalk8.gray(`- ${item.description}`)}`);
+    step(`Selected: ${brand(item.name)} ${chalk7.gray(`(${item.type})`)} ${chalk7.gray(`- ${item.description}`)}`);
     const handler = getHandler(item.type);
     if (!handler) {
       error(`No handler found for type "${item.type}"`);
       process.exit(1);
     }
-    let tools = resolveTools(options.agents, item);
-    const typeCompatible = filterCompatibleTools(item.type, item.compatibility);
-    if (tools.length === 0) {
+    let agents = resolveAgents(options.agents, item);
+    const typeCompatible = filterCompatibleAgents(item.type, item.compatibility);
+    if (agents.length === 0) {
       if (typeCompatible.length === 1) {
-        tools = typeCompatible;
+        agents = typeCompatible;
       } else {
-        const selected = await selectTools(typeCompatible);
+        const selected = await selectAgents(typeCompatible);
         if (p.isCancel(selected)) {
           cancelled();
           return;
         }
-        tools = selected;
+        agents = selected;
       }
     }
-    if (tools.length === 0) {
-      error("No valid tools selected");
+    if (agents.length === 0) {
+      error("No valid agents selected");
       process.exit(1);
     }
-    step(`Tools: ${chalk8.cyan(tools.join(", "))}`);
+    step(`Agents: ${brand(agents.join(", "))}`);
     let scope;
     if (options.scope) {
       scope = options.scope;
@@ -1009,11 +924,11 @@ var addCommand = new Command("add").description("Install a skill, agent, hook, o
       }
       scope = selected;
     }
-    step(`Scope: ${chalk8.cyan(scope)}`);
+    step(`Scope: ${brand(scope)}`);
     let method;
     if (options.method) {
       method = options.method;
-    } else if (tools.length === 1) {
+    } else if (agents.length === 1) {
       method = "copy";
     } else {
       const symlinkPath = getAgentsPath(item.type, item.slug, process.cwd());
@@ -1024,26 +939,26 @@ var addCommand = new Command("add").description("Install a skill, agent, hook, o
       }
       method = selected;
     }
-    step(`Method: ${chalk8.cyan(method)}`);
+    step(`Method: ${brand(method)}`);
     if (options.dryRun) {
       console.log();
-      printDryRunSummary(item, tools, scope, method, process.cwd());
-      outro2("Dry run complete");
+      printDryRunSummary(item, agents, scope, method, process.cwd());
+      outro("Dry run complete");
       return;
     }
     if (!options.yes) {
       console.log();
-      const confirmed = await confirm2("Proceed with installation?");
+      const confirmed = await confirm("Proceed with installation?");
       if (p.isCancel(confirmed) || !confirmed) {
         cancelled();
         return;
       }
     }
     console.log();
-    const results = await handler.install(item, tools, scope, method, process.cwd());
+    const results = await handler.install(item, agents, scope, method, process.cwd());
     trackInstalls(item.slug, item.type, results, scope);
     printInstallSummary(results);
-    outro2("Installation complete");
+    outro("Installation complete");
   } catch (error2) {
     handleCommandError(error2);
   }
@@ -1051,17 +966,17 @@ var addCommand = new Command("add").description("Install a skill, agent, hook, o
 
 // src/commands/list.ts
 import { Command as Command2 } from "commander";
-import chalk9 from "chalk";
+import chalk8 from "chalk";
 var SEPARATOR_WIDTH = 40;
 var SLUG_COLUMN_WIDTH = 24;
 var TYPE_COLORS = {
-  skill: chalk9.magenta,
-  hook: chalk9.hex("#a855f7"),
-  agent: chalk9.blue,
-  plugin: chalk9.hex("#6366f1"),
-  command: chalk9.hex("#f59e0b"),
-  settings: chalk9.hex("#f97316"),
-  mcp: chalk9.hex("#2dd4bf")
+  skill: chalk8.magenta,
+  hook: chalk8.hex("#a855f7"),
+  agent: chalk8.blue,
+  plugin: chalk8.hex("#6366f1"),
+  command: chalk8.hex("#f59e0b"),
+  settings: chalk8.hex("#f97316"),
+  mcp: chalk8.hex("#2dd4bf")
 };
 var listCommand = new Command2("list").alias("ls").description("List available or installed skills").option("-t, --type <type>", "Filter by type (skill, hook, agent, plugin)").option("-i, --installed", "Show only installed items").option("--scope <scope>", "Scope for installed check (project, user)", "project").action(async (options) => {
   try {
@@ -1077,52 +992,52 @@ var listCommand = new Command2("list").alias("ls").description("List available o
 async function listAvailable(type) {
   const items = await listItems(type);
   if (items.length === 0) {
-    console.log(chalk9.yellow("No items found in registry"));
+    console.log(chalk8.yellow("No items found in registry"));
     return;
   }
   const grouped = groupByType(items);
   for (const [itemType, typeItems] of Object.entries(grouped)) {
-    const colorFn = TYPE_COLORS[itemType] ?? chalk9.white;
+    const colorFn = TYPE_COLORS[itemType] ?? chalk8.white;
     console.log(colorFn(`
 ${itemType.toUpperCase()}S`));
-    console.log(chalk9.gray("\u2500".repeat(SEPARATOR_WIDTH)));
+    console.log(chalk8.gray("\u2500".repeat(SEPARATOR_WIDTH)));
     for (const item of typeItems) {
-      const compatIcons = item.compatibility.map((t) => AI_TOOLS[t].shortName).join(" ");
-      const featured = item.featured ? chalk9.yellow("\u2605 ") : "  ";
+      const compatIcons = item.compatibility.map((a) => CODING_AGENTS[a].shortName).join(" ");
+      const featured = item.featured ? chalk8.yellow("\u2605 ") : "  ";
       console.log(
-        `${featured}${chalk9.white(item.slug.padEnd(SLUG_COLUMN_WIDTH))} ${chalk9.gray(compatIcons)}`
+        `${featured}${chalk8.white(item.slug.padEnd(SLUG_COLUMN_WIDTH))} ${chalk8.gray(compatIcons)}`
       );
-      console.log(`   ${chalk9.gray(item.description)}`);
+      console.log(`   ${chalk8.gray(item.description)}`);
     }
   }
   console.log("");
   console.log(
-    chalk9.gray(`Total: ${items.length} items. Use 'npx @toolr/seedr add <name>' to install.`)
+    chalk8.gray(`Total: ${items.length} items. Use 'npx @toolr/seedr add <name>' to install.`)
   );
 }
 async function listInstalled(scope) {
-  console.log(chalk9.cyan(`
+  console.log(brand(`
 Installed skills (${scope} scope):
 `));
   let total = 0;
-  for (const tool of ALL_TOOLS) {
+  for (const agent of ALL_AGENTS) {
     const installed = await getInstalledSkills(
-      tool,
+      agent,
       scope
     );
     if (installed.length > 0) {
-      console.log(chalk9.blue(AI_TOOLS[tool].name));
+      console.log(chalk8.blue(CODING_AGENTS[agent].name));
       for (const skill of installed) {
-        console.log(`  ${chalk9.white(skill)}`);
+        console.log(`  ${chalk8.white(skill)}`);
         total++;
       }
       console.log("");
     }
   }
   if (total === 0) {
-    console.log(chalk9.yellow("No skills installed"));
+    console.log(chalk8.yellow("No skills installed"));
   } else {
-    console.log(chalk9.gray(`Total: ${total} installed`));
+    console.log(chalk8.gray(`Total: ${total} installed`));
   }
 }
 function groupByType(items) {
@@ -1140,7 +1055,7 @@ function groupByType(items) {
 
 // src/commands/remove.ts
 import { Command as Command3 } from "commander";
-import chalk10 from "chalk";
+import chalk9 from "chalk";
 import ora6 from "ora";
 
 // src/utils/prompts.ts
@@ -1158,37 +1073,37 @@ async function promptConfirm(message, defaultValue = true) {
 }
 
 // src/commands/remove.ts
-async function findInstalledTools(slug, type, scope) {
+async function findInstalledAgents(slug, type, scope) {
   const handler = getHandler(type);
   if (!handler) return [];
-  const tools = [];
-  for (const tool of ALL_TOOLS) {
-    const installed = await handler.listInstalled(tool, scope);
+  const agents = [];
+  for (const agent of ALL_AGENTS) {
+    const installed = await handler.listInstalled(agent, scope);
     if (installed.includes(slug)) {
-      tools.push(tool);
+      agents.push(agent);
     }
   }
-  return tools;
+  return agents;
 }
-async function removeFromTools(slug, type, tools, scope) {
+async function removeFromAgents(slug, type, agents, scope) {
   const handler = getHandler(type);
   if (!handler) return 0;
   let successCount = 0;
-  for (const tool of tools) {
-    const spinner = ora6(`Removing from ${AI_TOOLS[tool].name}...`).start();
-    const removed = await handler.uninstall(slug, tool, scope);
+  for (const agent of agents) {
+    const spinner = ora6(`Removing from ${CODING_AGENTS[agent].name}...`).start();
+    const removed = await handler.uninstall(slug, agent, scope);
     if (removed) {
-      spinner.succeed(chalk10.green(`Removed from ${AI_TOOLS[tool].name}`));
+      spinner.succeed(brand(`Removed from ${CODING_AGENTS[agent].name}`));
       successCount++;
     } else {
-      spinner.info(chalk10.gray(`Not found in ${AI_TOOLS[tool].name}`));
+      spinner.info(chalk9.gray(`Not found in ${CODING_AGENTS[agent].name}`));
     }
   }
   return successCount;
 }
 var removeCommand = new Command3("remove").alias("rm").description("Remove an installed item (skill, plugin, agent, hook, mcp)").argument("<name>", "Name/slug of the item to remove").option("-t, --type <type>", "Content type: skill, agent, hook, mcp, plugin, settings").option(
-  "-a, --agents <tools>",
-  "Comma-separated AI tools or 'all'"
+  "-a, --agents <agents>",
+  "Comma-separated coding agents or 'all'"
 ).option(
   "--scope <scope>",
   "Installation scope: project, user, or global",
@@ -1199,43 +1114,43 @@ var removeCommand = new Command3("remove").alias("rm").description("Remove an in
     const type = options.type;
     if (!type) {
       console.log(
-        chalk10.yellow(`Please specify the content type with --type (skill, plugin, agent, hook, mcp, settings)`)
+        chalk9.yellow(`Please specify the content type with --type (skill, plugin, agent, hook, mcp, settings)`)
       );
       process.exit(1);
     }
     const handler = getHandler(type);
     if (!handler) {
-      console.log(chalk10.red(`No handler found for type "${type}"`));
+      console.log(chalk9.red(`No handler found for type "${type}"`));
       process.exit(1);
     }
-    const tools = options.agents ? parseToolsArg(options.agents, ALL_TOOLS) : await findInstalledTools(name, type, scope);
-    if (tools.length === 0) {
+    const agents = options.agents ? parseAgentsArg(options.agents, ALL_AGENTS) : await findInstalledAgents(name, type, scope);
+    if (agents.length === 0) {
       console.log(
-        chalk10.yellow(`${type} "${name}" is not installed in ${scope} scope`)
+        chalk9.yellow(`${type} "${name}" is not installed in ${scope} scope`)
       );
       process.exit(0);
     }
     if (!options.yes) {
-      console.log(chalk10.cyan(`
+      console.log(brand(`
 Will remove ${type} "${name}" from:`));
-      for (const tool of tools) {
-        console.log(`  - ${AI_TOOLS[tool].name}`);
+      for (const agent of agents) {
+        console.log(`  - ${CODING_AGENTS[agent].name}`);
       }
       console.log("");
       const confirmed = await promptConfirm("Proceed with removal?");
       if (!confirmed) {
-        console.log(chalk10.yellow("Removal cancelled"));
+        console.log(chalk9.yellow("Removal cancelled"));
         process.exit(0);
       }
     }
-    const successCount = await removeFromTools(name, type, tools, scope);
+    const successCount = await removeFromAgents(name, type, agents, scope);
     console.log("");
     if (successCount > 0) {
       console.log(
-        chalk10.green(`Successfully removed from ${successCount} tool(s)`)
+        brand(`Successfully removed from ${successCount} agent(s)`)
       );
     } else {
-      console.log(chalk10.yellow("Nothing to remove"));
+      console.log(chalk9.yellow("Nothing to remove"));
     }
   } catch (error2) {
     handleCommandError(error2);
@@ -1244,39 +1159,39 @@ Will remove ${type} "${name}" from:`));
 
 // src/commands/init.ts
 import { Command as Command4 } from "commander";
-import chalk11 from "chalk";
+import chalk10 from "chalk";
 import ora7 from "ora";
 import { join as join4 } from "path";
-var initCommand = new Command4("init").description("Initialize AI tool configuration directories").option(
-  "-a, --agents <tools>",
-  "Comma-separated AI tools or 'all'",
+var initCommand = new Command4("init").description("Initialize coding agent configuration directories").option(
+  "-a, --agents <agents>",
+  "Comma-separated coding agents or 'all'",
   "claude"
 ).option("-y, --yes", "Skip confirmation prompts").action(async (options) => {
   try {
-    const tools = parseToolsArg(options.agents, ALL_TOOLS);
-    if (tools.length === 0) {
-      console.error(chalk11.red("No valid tools specified"));
+    const agents = parseAgentsArg(options.agents, ALL_AGENTS);
+    if (agents.length === 0) {
+      console.error(chalk10.red("No valid agents specified"));
       process.exit(1);
     }
-    console.log(chalk11.cyan("\nWill initialize configuration for:"));
-    for (const tool of tools) {
-      const path = getToolPath(tool, "project");
-      console.log(`  - ${AI_TOOLS[tool].name} \u2192 ${path}`);
+    console.log(brand("\nWill initialize configuration for:"));
+    for (const agent of agents) {
+      const path = getAgentPath(agent, "project");
+      console.log(`  - ${CODING_AGENTS[agent].name} \u2192 ${path}`);
     }
     console.log("");
     if (!options.yes) {
       const confirmed = await promptConfirm("Proceed?");
       if (!confirmed) {
-        console.log(chalk11.yellow("Cancelled"));
+        console.log(chalk10.yellow("Cancelled"));
         process.exit(0);
       }
     }
-    for (const tool of tools) {
-      const spinner = ora7(`Initializing ${AI_TOOLS[tool].name}...`).start();
-      const path = getToolPath(tool, "project");
+    for (const agent of agents) {
+      const spinner = ora7(`Initializing ${CODING_AGENTS[agent].name}...`).start();
+      const path = getAgentPath(agent, "project");
       if (await exists(path)) {
         spinner.info(
-          chalk11.gray(`${AI_TOOLS[tool].name} already initialized`)
+          chalk10.gray(`${CODING_AGENTS[agent].name} already initialized`)
         );
         continue;
       }
@@ -1284,23 +1199,23 @@ var initCommand = new Command4("init").description("Initialize AI tool configura
       const readmePath = join4(path, "README.md");
       await writeTextFile(
         readmePath,
-        `# ${AI_TOOLS[tool].name} Configuration
+        `# ${CODING_AGENTS[agent].name} Configuration
 
-This directory contains AI configuration files for ${AI_TOOLS[tool].name}.
+This directory contains AI configuration files for ${CODING_AGENTS[agent].name}.
 
 Add skills with:
 \`\`\`bash
-npx @toolr/seedr add <skill-name> --agents ${tool}
+npx @toolr/seedr add <skill-name> --agents ${agent}
 \`\`\`
 
 Browse available skills at https://seedr.toolr.dev
 `
       );
-      spinner.succeed(chalk11.green(`Initialized ${AI_TOOLS[tool].name}`));
+      spinner.succeed(brand(`Initialized ${CODING_AGENTS[agent].name}`));
     }
     console.log("");
     console.log(
-      chalk11.green("Done! Use 'npx @toolr/seedr add <skill>' to install skills.")
+      brand("Done! Use 'npx @toolr/seedr add <skill>' to install skills.")
     );
   } catch (error2) {
     handleCommandError(error2);
@@ -1309,18 +1224,9 @@ Browse available skills at https://seedr.toolr.dev
 
 // src/cli.ts
 var program = new Command5();
-program.name("seedr").description("Seed your projects with AI configurations").version("0.1.0").addCommand(addCommand).addCommand(listCommand).addCommand(removeCommand).addCommand(initCommand);
+program.name("seedr").description("Seed your projects with capabilities").version("0.1.0").addCommand(addCommand).addCommand(listCommand).addCommand(removeCommand).addCommand(initCommand);
 program.action(() => {
-  console.log(
-    chalk12.green(`
-  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
-  \u2551                                       \u2551
-  \u2551   \u{1F331} Seedr                            \u2551
-  \u2551   Seed your projects with AI configs  \u2551
-  \u2551                                       \u2551
-  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
-`)
-  );
+  printLogo();
   program.help();
 });
 program.parse();