@toolr/seedr 0.1.71 → 0.1.72

package/dist/{chunk-DI5Z3O3G.js → chunk-TWSBWCGS.js}

@@ -145,11 +145,11 @@ async function fetchFileTree(nodes, baseUrl, destPath) {
   }));
 }
 
-// src/config/tools.ts
+// src/config/agents.ts
 import { homedir } from "os";
 import { join as join2 } from "path";
 var home = homedir();
-var AI_TOOLS = {
+var CODING_AGENTS = {
   claude: {
     name: "Claude Code",
     shortName: "claude",
@@ -257,15 +257,15 @@ var AI_TOOLS = {
     }
   }
 };
-var ALL_TOOLS = Object.keys(AI_TOOLS);
-function getToolConfig(tool) {
-  return AI_TOOLS[tool];
+var ALL_AGENTS = Object.keys(CODING_AGENTS);
+function getAgentConfig(agent) {
+  return CODING_AGENTS[agent];
 }
-function getContentTypeConfig(tool, type) {
-  return AI_TOOLS[tool].contentTypes[type];
+function getContentTypeConfig(agent, type) {
+  return CODING_AGENTS[agent].contentTypes[type];
 }
-function getToolRoot(tool, scope, cwd = process.cwd()) {
-  const config = AI_TOOLS[tool];
+function getAgentRoot(agent, scope, cwd = process.cwd()) {
+  const config = CODING_AGENTS[agent];
   switch (scope) {
     case "project":
     case "local":
@@ -274,10 +274,10 @@ function getToolRoot(tool, scope, cwd = process.cwd()) {
       return config.userRoot;
   }
 }
-function getContentPath(tool, type, scope, cwd = process.cwd()) {
-  const typeConfig = getContentTypeConfig(tool, type);
+function getContentPath(agent, type, scope, cwd = process.cwd()) {
+  const typeConfig = getContentTypeConfig(agent, type);
   if (!typeConfig) return void 0;
-  const root = getToolRoot(tool, scope, cwd);
+  const root = getAgentRoot(agent, scope, cwd);
   return typeConfig.path ? join2(root, typeConfig.path) : root;
 }
 function getSettingsPath(scope, cwd = process.cwd()) {
@@ -299,8 +299,8 @@ function getMcpPath(scope, cwd = process.cwd()) {
       return join2(home, ".claude.json");
   }
 }
-function getToolPath(tool, scope, cwd = process.cwd()) {
-  return getContentPath(tool, "skill", scope, cwd) || "";
+function getAgentPath(agent, scope, cwd = process.cwd()) {
+  return getContentPath(agent, "skill", scope, cwd) || "";
 }
 
 // src/utils/fs.ts
@@ -373,34 +373,34 @@ async function installDirectory(source, destination, method) {
 }
 
 // src/utils/detection.ts
-async function detectInstalledTools(cwd = process.cwd()) {
-  const checks = ALL_TOOLS.flatMap((tool) => {
-    const projectPath = getToolPath(tool, "project", cwd);
-    const userPath = getToolPath(tool, "user", cwd);
+async function detectInstalledAgents(cwd = process.cwd()) {
+  const checks = ALL_AGENTS.flatMap((agent) => {
+    const projectPath = getAgentPath(agent, "project", cwd);
+    const userPath = getAgentPath(agent, "user", cwd);
     return [
-      exists(projectPath).then((found) => found ? { tool, scope: "project", path: projectPath } : null),
-      exists(userPath).then((found) => found ? { tool, scope: "user", path: userPath } : null)
+      exists(projectPath).then((found) => found ? { agent, scope: "project", path: projectPath } : null),
+      exists(userPath).then((found) => found ? { agent, scope: "user", path: userPath } : null)
     ];
   });
   const results = await Promise.all(checks);
   return results.filter((r) => r !== null);
 }
-async function detectProjectTools(cwd = process.cwd()) {
-  const checks = ALL_TOOLS.map(async (tool) => {
-    const projectPath = getToolPath(tool, "project", cwd);
-    return await exists(projectPath) ? tool : null;
+async function detectProjectAgents(cwd = process.cwd()) {
+  const checks = ALL_AGENTS.map(async (agent) => {
+    const projectPath = getAgentPath(agent, "project", cwd);
+    return await exists(projectPath) ? agent : null;
   });
   const results = await Promise.all(checks);
-  return results.filter((t) => t !== null);
+  return results.filter((a) => a !== null);
 }
-async function isToolInstalled(tool, scope, cwd = process.cwd()) {
+async function isAgentInstalled(agent, scope, cwd = process.cwd()) {
   const effectiveScope = scope === "local" ? "project" : scope;
-  const path = getToolPath(tool, effectiveScope, cwd);
+  const path = getAgentPath(agent, effectiveScope, cwd);
   return exists(path);
 }
-function parseToolArg(arg) {
+function parseAgentArg(arg) {
   const normalized = arg.toLowerCase().trim();
-  if (ALL_TOOLS.includes(normalized)) {
+  if (ALL_AGENTS.includes(normalized)) {
     return normalized;
   }
   const aliases = {
@@ -416,11 +416,11 @@ function parseToolArg(arg) {
   };
   return aliases[normalized] ?? null;
 }
-function parseToolsArg(agents, allTools) {
+function parseAgentsArg(agents, allAgents) {
   if (agents === "all") {
-    return allTools;
+    return allAgents;
   }
-  return agents.split(",").map((t) => parseToolArg(t.trim())).filter((t) => t !== null);
+  return agents.split(",").map((a) => parseAgentArg(a.trim())).filter((a) => a !== null);
 }
 
 // src/handlers/skill.ts
@@ -438,58 +438,58 @@ async function installToCentralLocation(item, sourcePath, cwd) {
   }
   return centralPath;
 }
-async function createToolSymlink(centralPath, destPath) {
+async function createAgentSymlink(centralPath, destPath) {
   await ensureDir(dirname3(destPath));
   await rm2(destPath, { recursive: true, force: true });
   const relPath = relative2(dirname3(destPath), centralPath);
   await symlink2(relPath, destPath);
 }
-async function installSkillForTool(item, tool, scope, method, cwd, centralPath) {
+async function installSkillForAgent(item, agent, scope, method, cwd, centralPath) {
   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, "skill", scope, cwd);
+    const destDir = getContentPath(agent, "skill", scope, cwd);
     if (!destDir) {
-      throw new Error(`${AI_TOOLS[tool].name} does not support skills`);
+      throw new Error(`${CODING_AGENTS[agent].name} does not support skills`);
     }
     const destPath = join4(destDir, item.slug);
     const sourcePath = getItemSourcePath(item);
     if (method === "symlink" && centralPath) {
-      await createToolSymlink(centralPath, destPath);
+      await createAgentSymlink(centralPath, destPath);
     } else if (sourcePath && await exists(sourcePath)) {
       await installDirectory(sourcePath, destPath, "copy");
     } else {
       await fetchItemToDestination(item, destPath);
     }
     spinner.succeed(
-      chalk.green(`Installed ${item.name} for ${AI_TOOLS[tool].name}`)
+      chalk.green(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
     );
-    return { tool, success: true, path: destPath };
+    return { agent, success: true, path: destPath };
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : "Unknown error";
     spinner.fail(
-      chalk.red(`Failed to install for ${AI_TOOLS[tool].name}: ${errorMsg}`)
+      chalk.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 installSkill(item, tools, scope, method, cwd = process.cwd()) {
+async function installSkill(item, agents, scope, method, cwd = process.cwd()) {
   const results = [];
   const sourcePath = getItemSourcePath(item);
   let centralPath;
   if (method === "symlink") {
     centralPath = await installToCentralLocation(item, sourcePath, cwd);
   }
-  for (const tool of tools) {
-    const readsAgentsDir = tool === "gemini" || tool === "codex" || tool === "opencode";
+  for (const agent of agents) {
+    const readsAgentsDir = agent === "gemini" || agent === "codex" || agent === "opencode";
     if (readsAgentsDir && method === "symlink" && centralPath) {
-      results.push({ tool, success: true, path: centralPath });
+      results.push({ agent, success: true, path: centralPath });
       continue;
     }
-    const result = await installSkillForTool(
+    const result = await installSkillForAgent(
       item,
-      tool,
+      agent,
       scope,
       method,
       cwd,
@@ -499,8 +499,8 @@ async function installSkill(item, tools, scope, method, cwd = process.cwd()) {
   }
   return results;
 }
-async function uninstallSkill(slug, tool, scope, cwd = process.cwd()) {
-  const destDir = getContentPath(tool, "skill", scope, cwd);
+async function uninstallSkill(slug, agent, scope, cwd = process.cwd()) {
+  const destDir = getContentPath(agent, "skill", scope, cwd);
   if (!destDir) return false;
   const destPath = join4(destDir, slug);
   if (!await exists(destPath)) {
@@ -509,8 +509,8 @@ async function uninstallSkill(slug, tool, scope, cwd = process.cwd()) {
   await rm2(destPath, { recursive: true });
   return true;
 }
-async function getInstalledSkills(tool, scope, cwd = process.cwd()) {
-  const destDir = getContentPath(tool, "skill", scope, cwd);
+async function getInstalledSkills(agent, scope, cwd = process.cwd()) {
+  const destDir = getContentPath(agent, "skill", scope, cwd);
   if (!destDir || !await exists(destDir)) {
     return [];
   }
@@ -519,14 +519,14 @@ async function getInstalledSkills(tool, scope, cwd = process.cwd()) {
 }
 var skillHandler = {
   type: "skill",
-  async install(item, tools, scope, method, cwd) {
-    return installSkill(item, tools, scope, method, cwd);
+  async install(item, agents, scope, method, cwd) {
+    return installSkill(item, agents, scope, method, cwd);
   },
-  async uninstall(slug, tool, scope, cwd) {
-    return uninstallSkill(slug, tool, scope, cwd);
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallSkill(slug, agent, scope, cwd);
   },
-  async listInstalled(tool, scope, cwd) {
-    return getInstalledSkills(tool, scope, cwd);
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledSkills(agent, scope, cwd);
   }
 };
 
@@ -545,17 +545,17 @@ export {
   writeTextFile,
   getAgentsPath,
   installDirectory,
-  AI_TOOLS,
-  ALL_TOOLS,
-  getToolConfig,
+  CODING_AGENTS,
+  ALL_AGENTS,
+  getAgentConfig,
   getContentPath,
   getSettingsPath,
   getMcpPath,
-  getToolPath,
-  detectInstalledTools,
-  detectProjectTools,
-  isToolInstalled,
-  parseToolsArg,
+  getAgentPath,
+  detectInstalledAgents,
+  detectProjectAgents,
+  isAgentInstalled,
+  parseAgentsArg,
   installSkill,
   uninstallSkill,
   getInstalledSkills,

package/dist/cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import {
-  AI_TOOLS,
-  ALL_TOOLS,
+  ALL_AGENTS,
+  CODING_AGENTS,
   ensureDir,
   exists,
   fetchItemToDestination,
+  getAgentPath,
   getAgentsPath,
   getContentPath,
   getInstalledSkills,
@@ -13,16 +14,15 @@ import {
   getItemSourcePath,
   getMcpPath,
   getSettingsPath,
-  getToolPath,
   installDirectory,
   installFile,
   listItems,
-  parseToolsArg,
+  parseAgentsArg,
   removeFile,
   searchItems,
   skillHandler,
   writeTextFile
-} from "./chunk-DI5Z3O3G.js";
+} from "./chunk-TWSBWCGS.js";
 
 // src/cli.ts
 import { Command as Command5 } from "commander";
@@ -62,22 +62,22 @@ async function selectSkill(items) {
   });
   return result;
 }
-async function selectTools(compatible) {
+async function selectAgents(compatible) {
   const allOption = await p.select({
-    message: "Which AI tools do you want to install for?",
+    message: "Which coding agents do you want to install for?",
     options: [
       { label: `All (${compatible.length} agents)`, value: "all" },
-      { label: "Select specific tools...", value: "select" }
+      { label: "Select specific agents...", 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
+    message: "Select agents",
+    options: compatible.map((agent) => ({
+      label: CODING_AGENTS[agent].name,
+      value: agent,
+      hint: CODING_AGENTS[agent].projectRoot
     })),
     initialValues: ["claude"],
     required: true
@@ -98,7 +98,7 @@ async function selectMethod(symlinkPath) {
     message: "Installation method",
     options: [
       { label: "Symlink", value: "symlink", hint: `shared at ${symlinkPath}` },
-      { label: "Copy", value: "copy", hint: "standalone copy per tool" }
+      { label: "Copy", value: "copy", hint: "standalone copy per agent" }
     ]
   });
   return result;
@@ -162,9 +162,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.72"
       }),
       signal: AbortSignal.timeout(4e3)
     }).catch(() => {
@@ -173,7 +173,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,9 +182,9 @@ 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
@@ -192,14 +192,14 @@ import { join } from "path";
 import { readdir } from "fs/promises";
 import chalk3 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 +218,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}`)
+      chalk3.green(`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}`)
+      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 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 +246,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 +256,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);
   }
 };
 
@@ -338,12 +338,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 +401,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}`)
+      chalk4.green(`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}`)
+      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 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 +469,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,14 +488,14 @@ 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);
   }
 };
 
@@ -509,9 +509,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 +522,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}`)
+      chalk5.green(`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}`)
+      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 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 +552,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,14 +560,14 @@ 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);
   }
 };
 
@@ -581,12 +581,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 +596,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}`)
+      chalk6.green(`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}`)
+      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 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 +642,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 +662,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);
   }
 };
 
@@ -728,12 +728,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 +779,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}`)
+      chalk7.green(`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}`)
+      chalk7.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 +824,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 +842,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,19 +904,19 @@ 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)}`);
@@ -928,13 +928,13 @@ function printDryRunSummary(item, tools, scope, method, cwd) {
     console.log(chalk8.cyan("  Central storage:"));
     console.log(`    ${chalk8.gray("\u2192")} ${chalk8.gray(centralPath)}`);
     console.log();
-    console.log(chalk8.cyan("  Symlinks from tool folders:"));
+    console.log(chalk8.cyan("  Symlinks from agent folders:"));
   } else {
     console.log(chalk8.cyan("  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")}`);
       continue;
@@ -948,22 +948,22 @@ 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}`));
     }
   }
   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(chalk8.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();
@@ -978,25 +978,25 @@ var addCommand = new Command("add").description("Install a skill, agent, hook, o
       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: ${chalk8.cyan(agents.join(", "))}`);
     let scope;
     if (options.scope) {
       scope = options.scope;
@@ -1013,7 +1013,7 @@ var addCommand = new Command("add").description("Install a skill, agent, hook, o
     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());
@@ -1027,7 +1027,7 @@ var addCommand = new Command("add").description("Install a skill, agent, hook, o
     step(`Method: ${chalk8.cyan(method)}`);
     if (options.dryRun) {
       console.log();
-      printDryRunSummary(item, tools, scope, method, process.cwd());
+      printDryRunSummary(item, agents, scope, method, process.cwd());
       outro2("Dry run complete");
       return;
     }
@@ -1040,7 +1040,7 @@ var addCommand = new Command("add").description("Install a skill, agent, hook, o
       }
     }
     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");
@@ -1087,7 +1087,7 @@ async function listAvailable(type) {
 ${itemType.toUpperCase()}S`));
     console.log(chalk9.gray("\u2500".repeat(SEPARATOR_WIDTH)));
     for (const item of typeItems) {
-      const compatIcons = item.compatibility.map((t) => AI_TOOLS[t].shortName).join(" ");
+      const compatIcons = item.compatibility.map((a) => CODING_AGENTS[a].shortName).join(" ");
       const featured = item.featured ? chalk9.yellow("\u2605 ") : "  ";
       console.log(
         `${featured}${chalk9.white(item.slug.padEnd(SLUG_COLUMN_WIDTH))} ${chalk9.gray(compatIcons)}`
@@ -1105,13 +1105,13 @@ async function listInstalled(scope) {
 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(chalk9.blue(CODING_AGENTS[agent].name));
       for (const skill of installed) {
         console.log(`  ${chalk9.white(skill)}`);
         total++;
@@ -1158,37 +1158,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(chalk10.green(`Removed from ${CODING_AGENTS[agent].name}`));
       successCount++;
     } else {
-      spinner.info(chalk10.gray(`Not found in ${AI_TOOLS[tool].name}`));
+      spinner.info(chalk10.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",
@@ -1208,8 +1208,8 @@ var removeCommand = new Command3("remove").alias("rm").description("Remove an in
       console.log(chalk10.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`)
       );
@@ -1218,8 +1218,8 @@ var removeCommand = new Command3("remove").alias("rm").description("Remove an in
     if (!options.yes) {
       console.log(chalk10.cyan(`
 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?");
@@ -1228,11 +1228,11 @@ Will remove ${type} "${name}" from:`));
         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)`)
+        chalk10.green(`Successfully removed from ${successCount} agent(s)`)
       );
     } else {
       console.log(chalk10.yellow("Nothing to remove"));
@@ -1247,21 +1247,21 @@ import { Command as Command4 } from "commander";
 import chalk11 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(chalk11.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}`);
+    for (const agent of agents) {
+      const path = getAgentPath(agent, "project");
+      console.log(`  - ${CODING_AGENTS[agent].name} \u2192 ${path}`);
     }
     console.log("");
     if (!options.yes) {
@@ -1271,12 +1271,12 @@ var initCommand = new Command4("init").description("Initialize AI tool configura
         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`)
+          chalk11.gray(`${CODING_AGENTS[agent].name} already initialized`)
         );
         continue;
       }
@@ -1284,19 +1284,19 @@ 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(chalk11.green(`Initialized ${CODING_AGENTS[agent].name}`));
     }
     console.log("");
     console.log(

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { ComponentType, AITool, RegistryItem, RegistryManifest } from '@seedr/shared';
-export { AITool, ComponentType, RegistryItem, RegistryManifest } from '@seedr/shared';
+import { ComponentType, CodingAgent, RegistryItem, RegistryManifest } from '@seedr/shared';
+export { CodingAgent, ComponentType, RegistryItem, RegistryManifest } from '@seedr/shared';
 
 type InstallScope = "project" | "user" | "local";
 type InstallMethod = "symlink" | "copy";
 type ContentStructure = "directory" | "file" | "json-merge" | "plugin";
 interface ContentTypeConfig {
-    /** Relative path from tool root (e.g., "skills", "agents") */
+    /** Relative path from agent root (e.g., "skills", "agents") */
     path: string;
     /** File extension (e.g., ".md") */
     extension: string;
@@ -18,7 +18,7 @@ interface ContentTypeConfig {
     /** For json-merge: field to merge into (e.g., "hooks", "mcpServers") */
     mergeField?: string;
 }
-interface AIToolConfig {
+interface CodingAgentConfig {
     /** Display name (e.g., "Claude Code") */
     name: string;
     /** Short identifier (e.g., "claude") */
@@ -41,17 +41,17 @@ interface InstallOptions {
 interface InstalledItem {
     slug: string;
     type: string;
-    tool: string;
+    agent: string;
     scope: InstallScope;
     method: InstallMethod;
     path: string;
     installedAt: string;
 }
 
-declare const AI_TOOLS: Record<AITool, AIToolConfig>;
-declare const ALL_TOOLS: AITool[];
-declare function getToolConfig(tool: AITool): AIToolConfig;
-declare function getToolPath(tool: AITool, scope: "project" | "user", cwd?: string): string;
+declare const CODING_AGENTS: Record<CodingAgent, CodingAgentConfig>;
+declare const ALL_AGENTS: CodingAgent[];
+declare function getAgentConfig(agent: CodingAgent): CodingAgentConfig;
+declare function getAgentPath(agent: CodingAgent, scope: "project" | "user", cwd?: string): string;
 
 declare function loadManifest(): Promise<RegistryManifest>;
 declare function getItem(slug: string, type?: ComponentType): Promise<RegistryItem | undefined>;
@@ -63,15 +63,15 @@ declare function searchItems(query: string): Promise<RegistryItem[]>;
 declare function getItemContent(item: RegistryItem): Promise<string>;
 
 interface InstallResult {
-    tool: AITool;
+    agent: CodingAgent;
     success: boolean;
     path: string;
     error?: string;
 }
 
-declare function installSkill(item: RegistryItem, tools: AITool[], scope: InstallScope, method: InstallMethod, cwd?: string): Promise<InstallResult[]>;
-declare function uninstallSkill(slug: string, tool: AITool, scope: InstallScope, cwd?: string): Promise<boolean>;
-declare function getInstalledSkills(tool: AITool, scope: InstallScope, cwd?: string): Promise<string[]>;
+declare function installSkill(item: RegistryItem, agents: CodingAgent[], scope: InstallScope, method: InstallMethod, cwd?: string): Promise<InstallResult[]>;
+declare function uninstallSkill(slug: string, agent: CodingAgent, scope: InstallScope, cwd?: string): Promise<boolean>;
+declare function getInstalledSkills(agent: CodingAgent, scope: InstallScope, cwd?: string): Promise<string[]>;
 
 /**
  * Strategy pattern interfaces for skill conversion.
@@ -114,15 +114,15 @@ declare function parseSkillMarkdown(content: string): ParsedSkill;
  * @param targetTool - The AI tool to convert for
  * @returns Converted content string
  */
-declare function convertSkillToTool(content: string, targetTool: AITool): string;
+declare function convertSkillToTool(content: string, targetTool: CodingAgent): string;
 
-interface DetectedTool {
-    tool: AITool;
+interface DetectedAgent {
+    agent: CodingAgent;
     scope: InstallScope;
     path: string;
 }
-declare function detectInstalledTools(cwd?: string): Promise<DetectedTool[]>;
-declare function detectProjectTools(cwd?: string): Promise<AITool[]>;
-declare function isToolInstalled(tool: AITool, scope: InstallScope, cwd?: string): Promise<boolean>;
+declare function detectInstalledAgents(cwd?: string): Promise<DetectedAgent[]>;
+declare function detectProjectAgents(cwd?: string): Promise<CodingAgent[]>;
+declare function isAgentInstalled(agent: CodingAgent, scope: InstallScope, cwd?: string): Promise<boolean>;
 
-export { type AIToolConfig, AI_TOOLS, ALL_TOOLS, type InstallMethod, type InstallOptions, type InstallScope, type InstalledItem, convertSkillToTool, detectInstalledTools, detectProjectTools, getInstalledSkills, getItem, getItemContent, getToolConfig, getToolPath, installSkill, isToolInstalled, listItems, loadManifest, parseSkillMarkdown, searchItems, uninstallSkill };
+export { ALL_AGENTS, CODING_AGENTS, type CodingAgentConfig, type InstallMethod, type InstallOptions, type InstallScope, type InstalledItem, convertSkillToTool, detectInstalledAgents, detectProjectAgents, getAgentConfig, getAgentPath, getInstalledSkills, getItem, getItemContent, installSkill, isAgentInstalled, listItems, loadManifest, parseSkillMarkdown, searchItems, uninstallSkill };

package/dist/index.js

@@ -1,21 +1,21 @@
 #!/usr/bin/env node
 import {
-  AI_TOOLS,
-  ALL_TOOLS,
-  detectInstalledTools,
-  detectProjectTools,
+  ALL_AGENTS,
+  CODING_AGENTS,
+  detectInstalledAgents,
+  detectProjectAgents,
+  getAgentConfig,
+  getAgentPath,
   getInstalledSkills,
   getItem,
   getItemContent,
-  getToolConfig,
-  getToolPath,
   installSkill,
-  isToolInstalled,
+  isAgentInstalled,
   listItems,
   loadManifest,
   searchItems,
   uninstallSkill
-} from "./chunk-DI5Z3O3G.js";
+} from "./chunk-TWSBWCGS.js";
 
 // src/converters/index.ts
 import matter from "gray-matter";
@@ -120,18 +120,18 @@ function convertSkillToTool(content, targetTool) {
   return converter.convert(skill);
 }
 export {
-  AI_TOOLS,
-  ALL_TOOLS,
+  ALL_AGENTS,
+  CODING_AGENTS,
   convertSkillToTool,
-  detectInstalledTools,
-  detectProjectTools,
+  detectInstalledAgents,
+  detectProjectAgents,
+  getAgentConfig,
+  getAgentPath,
   getInstalledSkills,
   getItem,
   getItemContent,
-  getToolConfig,
-  getToolPath,
   installSkill,
-  isToolInstalled,
+  isAgentInstalled,
   listItems,
   loadManifest,
   parseSkillMarkdown,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolr/seedr",
-  "version": "0.1.71",
+  "version": "0.1.72",
   "description": "Seed your projects with AI configurations",
   "type": "module",
   "bin": {