@danieldeusing/seedr 0.1.80

package/dist/cli.js

@@ -0,0 +1,1232 @@
+#!/usr/bin/env node
+import {
+  ALL_AGENTS,
+  CODING_AGENTS,
+  brand,
+  cancelled,
+  confirm,
+  ensureDir,
+  error,
+  exists,
+  fetchItemToDestination,
+  getAgentPath,
+  getAgentsPath,
+  getContentPath,
+  getInstalledSkills,
+  getItem,
+  getItemContent,
+  getItemSourcePath,
+  getMcpPath,
+  getSettingsPath,
+  info,
+  installDirectory,
+  installFile,
+  intro,
+  listItems,
+  outro,
+  p,
+  parseAgentsArg,
+  printLogo,
+  removeFile,
+  searchItems,
+  selectAgents,
+  selectMethod,
+  selectScope,
+  selectSkill,
+  skillHandler,
+  step,
+  success,
+  warn,
+  writeTextFile
+} from "./chunk-5XFKC3T7.js";
+
+// src/cli.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/add.ts
+import { Command } from "commander";
+import chalk7 from "chalk";
+
+// src/handlers/registry.ts
+var handlers = /* @__PURE__ */ new Map();
+function registerHandler(handler) {
+  handlers.set(handler.type, handler);
+}
+function getHandler(type) {
+  return handlers.get(type);
+}
+
+// src/utils/errors.ts
+import chalk from "chalk";
+function handleCommandError(error2) {
+  console.error(
+    chalk.red(`Error: ${error2 instanceof Error ? error2.message : "Unknown error"}`)
+  );
+  process.exit(1);
+}
+
+// src/utils/analytics.ts
+var ANALYTICS_URL = "https://seedr.danieldeusing.de/api/installs";
+function trackInstalls(slug, type, results, scope) {
+  if (process.env.SEEDR_NO_TELEMETRY) return;
+  for (const result of results) {
+    if (!result.success) continue;
+    fetch(ANALYTICS_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        slug,
+        type,
+        agent: result.agent,
+        scope,
+        version: "0.1.80"
+      }),
+      signal: AbortSignal.timeout(4e3)
+    }).catch(() => {
+    });
+  }
+}
+
+// src/config/compatibility.ts
+var AGENT_COMPATIBILITY = {
+  skill: ["claude", "copilot", "gemini", "codex", "opencode"],
+  command: ["claude"],
+  agent: ["claude"],
+  hook: ["claude"],
+  plugin: ["claude"],
+  settings: ["claude"],
+  mcp: ["claude", "copilot", "gemini", "codex", "opencode"]
+};
+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 chalk2 from "chalk";
+import ora from "ora";
+async function installAgentForCodingAgent(item, agent, scope, method, cwd) {
+  const spinner = ora(
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
+  ).start();
+  try {
+    const destDir = getContentPath(agent, "agent", scope, cwd);
+    if (!destDir) {
+      throw new Error(`${CODING_AGENTS[agent].name} does not support agents`);
+    }
+    const destPath = join(destDir, `${item.slug}.md`);
+    const sourcePath = getItemSourcePath(item);
+    if (sourcePath && method === "symlink") {
+      const sourceFile = join(sourcePath, "AGENT.md");
+      if (await exists(sourceFile)) {
+        await installFile(sourceFile, destPath, "symlink");
+      } else {
+        const content = await getItemContent(item);
+        await ensureDir(destDir);
+        await writeTextFile(destPath, content);
+      }
+    } else {
+      const content = await getItemContent(item);
+      await ensureDir(destDir);
+      await writeTextFile(destPath, content);
+    }
+    spinner.succeed(
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
+    );
+    return { agent, success: true, path: destPath };
+  } catch (error2) {
+    const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
+    spinner.fail(
+      chalk2.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
+    );
+    return { agent, success: false, path: "", error: errorMsg };
+  }
+}
+async function installAgent(item, agents, scope, method, cwd = process.cwd()) {
+  const results = [];
+  for (const agent of agents) {
+    const result = await installAgentForCodingAgent(item, agent, scope, method, cwd);
+    results.push(result);
+  }
+  return results;
+}
+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)) {
+    return false;
+  }
+  return removeFile(destPath);
+}
+async function getInstalledAgents(agent, scope, cwd = process.cwd()) {
+  const destDir = getContentPath(agent, "agent", scope, cwd);
+  if (!destDir || !await exists(destDir)) {
+    return [];
+  }
+  const files = await readdir(destDir);
+  return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+}
+var agentHandler = {
+  type: "agent",
+  async install(item, agents, scope, method, cwd) {
+    return installAgent(item, agents, scope, method, cwd);
+  },
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallAgent(slug, agent, scope, cwd);
+  },
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledAgents(agent, scope, cwd);
+  }
+};
+
+// src/handlers/hook.ts
+import { join as join2, basename } from "path";
+import { homedir } from "os";
+import { mkdir, copyFile, chmod, rm } from "fs/promises";
+import chalk3 from "chalk";
+import ora2 from "ora";
+
+// src/utils/json.ts
+import { readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+async function readJson(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error2) {
+    if (error2.code === "ENOENT") {
+      return {};
+    }
+    throw error2;
+  }
+}
+async function writeJson(path, data) {
+  await ensureDir(dirname(path));
+  await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+
+// src/handlers/hook.ts
+function getHooksDir(scope, cwd) {
+  switch (scope) {
+    case "user":
+      return join2(homedir(), ".claude", "hooks");
+    case "project":
+    case "local":
+      return join2(cwd, ".claude", "hooks");
+  }
+}
+function getScriptPath(scope, scriptName) {
+  switch (scope) {
+    case "user":
+      return `~/.claude/hooks/${scriptName}`;
+    case "project":
+    case "local":
+      return `.claude/hooks/${scriptName}`;
+  }
+}
+function findScriptFile(item) {
+  const files = item.contents?.files;
+  if (!files) return null;
+  for (const file of files) {
+    if (file.type === "file" && file.name.endsWith(".sh")) {
+      return file.name;
+    }
+  }
+  return null;
+}
+async function installHookForAgent(item, agent, scope, _method, cwd) {
+  const spinner = ora2(
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
+  ).start();
+  try {
+    if (agent !== "claude") {
+      throw new Error("Hooks are only supported for Claude Code");
+    }
+    const triggers = item.contents?.triggers;
+    if (!triggers || triggers.length === 0) {
+      throw new Error("No triggers defined for this hook");
+    }
+    const scriptFile = findScriptFile(item);
+    if (!scriptFile) {
+      throw new Error("No script file found in hook");
+    }
+    const hooksDir = getHooksDir(scope, cwd);
+    await mkdir(hooksDir, { recursive: true });
+    const sourcePath = getItemSourcePath(item);
+    const destScriptPath = join2(hooksDir, scriptFile);
+    if (sourcePath && await exists(sourcePath)) {
+      const sourceScriptPath = join2(sourcePath, scriptFile);
+      await copyFile(sourceScriptPath, destScriptPath);
+    } else {
+      const tempDir = join2(cwd, ".claude", ".tmp", item.slug);
+      await fetchItemToDestination(item, tempDir);
+      await copyFile(join2(tempDir, scriptFile), destScriptPath);
+      await rm(tempDir, { recursive: true, force: true });
+    }
+    await chmod(destScriptPath, 493);
+    const settingsPath = getSettingsPath(scope, cwd);
+    const settings = await readJson(settingsPath);
+    settings.hooks = settings.hooks || {};
+    const scriptPath = getScriptPath(scope, scriptFile);
+    for (const trigger of triggers) {
+      const event = trigger.event;
+      const matcher = trigger.matcher;
+      if (!settings.hooks[event]) {
+        settings.hooks[event] = [];
+      }
+      const existingEntry = settings.hooks[event].find(
+        (e) => e.matcher === matcher
+      );
+      const hookCommand = { type: "command", command: scriptPath };
+      if (existingEntry) {
+        const alreadyExists = existingEntry.hooks.some(
+          (h) => h.command === scriptPath
+        );
+        if (!alreadyExists) {
+          existingEntry.hooks.push(hookCommand);
+        }
+      } else {
+        const newEntry = {
+          hooks: [hookCommand]
+        };
+        if (matcher) {
+          newEntry.matcher = matcher;
+        }
+        settings.hooks[event].push(newEntry);
+      }
+    }
+    await writeJson(settingsPath, settings);
+    spinner.succeed(
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
+    );
+    return { agent, success: true, path: destScriptPath };
+  } catch (error2) {
+    const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
+    spinner.fail(
+      chalk3.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
+    );
+    return { agent, success: false, path: "", error: errorMsg };
+  }
+}
+async function installHook(item, agents, scope, method, cwd = process.cwd()) {
+  const results = [];
+  for (const agent of agents) {
+    const result = await installHookForAgent(item, agent, scope, method, cwd);
+    results.push(result);
+  }
+  return results;
+}
+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");
+  const scriptFile = item ? findScriptFile(item) : null;
+  const expectedPath = scriptFile ? getScriptPath(scope, scriptFile) : null;
+  const settings = await readJson(settingsPath);
+  if (!settings.hooks) return false;
+  let removed = false;
+  for (const event of Object.keys(settings.hooks)) {
+    const entries = settings.hooks[event];
+    if (!entries) continue;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const entry = entries[i];
+      const originalLength = entry.hooks.length;
+      entry.hooks = entry.hooks.filter((h) => {
+        if (expectedPath && h.command === expectedPath) return false;
+        const cmdBasename = basename(h.command, ".sh");
+        return cmdBasename !== slug;
+      });
+      if (entry.hooks.length < originalLength) {
+        removed = true;
+      }
+      if (entry.hooks.length === 0) {
+        entries.splice(i, 1);
+      }
+    }
+    if (entries.length === 0) {
+      delete settings.hooks[event];
+    }
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  if (removed) {
+    await writeJson(settingsPath, settings);
+  }
+  const hooksDir = getHooksDir(scope, cwd);
+  const scriptFileName = scriptFile || `${slug}.sh`;
+  const scriptFilePath = join2(hooksDir, scriptFileName);
+  try {
+    await rm(scriptFilePath);
+    removed = true;
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  return removed;
+}
+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);
+  if (!settings.hooks) return [];
+  const slugs = /* @__PURE__ */ new Set();
+  for (const entries of Object.values(settings.hooks)) {
+    for (const entry of entries) {
+      for (const hook of entry.hooks) {
+        const slug = basename(hook.command, ".sh");
+        slugs.add(slug);
+      }
+    }
+  }
+  return Array.from(slugs);
+}
+var hookHandler = {
+  type: "hook",
+  async install(item, agents, scope, method, cwd) {
+    return installHook(item, agents, scope, method, cwd);
+  },
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallHook(slug, agent, scope, cwd);
+  },
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledHooks(agent, scope, cwd);
+  }
+};
+
+// src/handlers/mcp.ts
+import chalk4 from "chalk";
+import ora3 from "ora";
+function parseMcpDefinition(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error("Invalid MCP definition: must be valid JSON");
+  }
+}
+async function installMcpForAgent(item, agent, scope, _method, cwd) {
+  const spinner = ora3(
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
+  ).start();
+  try {
+    const content = await getItemContent(item);
+    const mcpDef = parseMcpDefinition(content);
+    const configPath = getMcpPath(scope, cwd);
+    const config = await readJson(configPath);
+    config.mcpServers = config.mcpServers || {};
+    config.mcpServers[mcpDef.name] = mcpDef.config;
+    await writeJson(configPath, config);
+    spinner.succeed(
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
+    );
+    return { agent, success: true, path: configPath };
+  } catch (error2) {
+    const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
+    spinner.fail(
+      chalk4.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
+    );
+    return { agent, success: false, path: "", error: errorMsg };
+  }
+}
+async function installMcp(item, agents, scope, method, cwd = process.cwd()) {
+  const results = [];
+  for (const agent of agents) {
+    const result = await installMcpForAgent(item, agent, scope, method, cwd);
+    results.push(result);
+  }
+  return results;
+}
+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);
+  if (!config.mcpServers || !(slug in config.mcpServers)) {
+    return false;
+  }
+  delete config.mcpServers[slug];
+  await writeJson(configPath, config);
+  return true;
+}
+async function getInstalledMcpServers(_agent, scope, cwd = process.cwd()) {
+  const configPath = getMcpPath(scope, cwd);
+  if (!await exists(configPath)) return [];
+  const config = await readJson(configPath);
+  return Object.keys(config.mcpServers || {});
+}
+var mcpHandler = {
+  type: "mcp",
+  async install(item, agents, scope, method, cwd) {
+    return installMcp(item, agents, scope, method, cwd);
+  },
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallMcp(slug, agent, scope, cwd);
+  },
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledMcpServers(agent, scope, cwd);
+  }
+};
+
+// src/handlers/settings.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+function parseSettings(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error("Invalid settings: must be valid JSON");
+  }
+}
+async function installSettingsForAgent(item, agent, scope, _method, cwd) {
+  const spinner = ora4(
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
+  ).start();
+  try {
+    if (agent !== "claude") {
+      throw new Error("Settings are only supported for Claude Code");
+    }
+    const content = await getItemContent(item);
+    const newSettings = parseSettings(content);
+    const settingsPath = getSettingsPath(scope, cwd);
+    const existingSettings = await readJson(settingsPath);
+    const merged = deepMerge(existingSettings, newSettings);
+    await writeJson(settingsPath, merged);
+    spinner.succeed(
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
+    );
+    return { agent, success: true, path: settingsPath };
+  } catch (error2) {
+    const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
+    spinner.fail(
+      chalk5.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
+    );
+    return { agent, success: false, path: "", error: errorMsg };
+  }
+}
+async function installSettings(item, agents, scope, method, cwd = process.cwd()) {
+  const results = [];
+  for (const agent of agents) {
+    const result = await installSettingsForAgent(item, agent, scope, method, cwd);
+    results.push(result);
+  }
+  return results;
+}
+function deepUnmerge(target, source) {
+  let changed = false;
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (!(key in result)) continue;
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+      const nested = deepUnmerge(
+        targetValue,
+        sourceValue
+      );
+      if (nested.changed) {
+        changed = true;
+        if (Object.keys(nested.result).length === 0) {
+          delete result[key];
+        } else {
+          result[key] = nested.result;
+        }
+      }
+    } else {
+      delete result[key];
+      changed = true;
+    }
+  }
+  return { result, changed };
+}
+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;
+  try {
+    content = await getItemContent(item);
+  } catch {
+    return false;
+  }
+  const itemSettings = parseSettings(content);
+  const settingsPath = getSettingsPath(scope, cwd);
+  if (!await exists(settingsPath)) return false;
+  const currentSettings = await readJson(settingsPath);
+  const { result, changed } = deepUnmerge(currentSettings, itemSettings);
+  if (changed) {
+    await writeJson(settingsPath, result);
+  }
+  return changed;
+}
+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, agents, scope, method, cwd) {
+    return installSettings(item, agents, scope, method, cwd);
+  },
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallSettings(slug, agent, scope, cwd);
+  },
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledSettings(agent, scope, cwd);
+  }
+};
+
+// src/handlers/plugin.ts
+import { homedir as homedir2 } from "os";
+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 chalk6 from "chalk";
+import ora5 from "ora";
+var home = homedir2();
+var PLUGINS_CACHE_DIR = join3(home, ".claude/plugins/cache");
+var INSTALLED_PLUGINS_PATH = join3(home, ".claude/plugins/installed_plugins.json");
+var KNOWN_MARKETPLACES_PATH = join3(home, ".claude/plugins/known_marketplaces.json");
+var MARKETPLACES_DIR = join3(home, ".claude/plugins/marketplaces");
+function getPluginCachePath(marketplace, name, version) {
+  return join3(PLUGINS_CACHE_DIR, marketplace, name, version);
+}
+function getPluginId(name, marketplace) {
+  return `${name}@${marketplace}`;
+}
+function extractGitHubRepo(url) {
+  const match = url.match(/github\.com\/([^/]+\/[^/]+)/);
+  return match?.[1]?.replace(/\.git$/, "") ?? null;
+}
+async function ensureMarketplaceRegistered(marketplace, item) {
+  const known = await readJson(
+    KNOWN_MARKETPLACES_PATH
+  );
+  if (known[marketplace]) return;
+  const repo = item.externalUrl ? extractGitHubRepo(item.externalUrl) : null;
+  if (!repo) return;
+  const installLocation = join3(MARKETPLACES_DIR, marketplace);
+  const execFileAsync = promisify(execFile);
+  await mkdir2(MARKETPLACES_DIR, { recursive: true });
+  await execFileAsync("git", [
+    "clone",
+    "--depth",
+    "1",
+    `https://github.com/${repo}.git`,
+    installLocation
+  ]);
+  known[marketplace] = {
+    source: { source: "github", repo },
+    installLocation,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJson(KNOWN_MARKETPLACES_PATH, known);
+}
+async function installPluginForAgent(item, agent, scope, method, cwd) {
+  const spinner = ora5(
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
+  ).start();
+  try {
+    if (agent !== "claude") {
+      throw new Error("Plugins are only supported for Claude Code");
+    }
+    const tmpPath = join3(PLUGINS_CACHE_DIR, ".tmp", item.slug);
+    const sourcePath = getItemSourcePath(item);
+    if (sourcePath) {
+      await installDirectory(sourcePath, tmpPath, method);
+    } else {
+      await fetchItemToDestination(item, tmpPath);
+    }
+    const pluginJson = await readJson(
+      join3(tmpPath, ".claude-plugin", "plugin.json")
+    );
+    const marketplace = item.marketplace || item.author?.name || "seedr";
+    const pluginName = pluginJson.name || item.slug;
+    const version = pluginJson.version || "1.0.0";
+    const pluginId = getPluginId(pluginName, marketplace);
+    await ensureMarketplaceRegistered(marketplace, item);
+    const cachePath = getPluginCachePath(marketplace, pluginName, version);
+    await installDirectory(tmpPath, cachePath, "copy");
+    await rm2(tmpPath, { recursive: true, force: true });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const registry = await readJson(INSTALLED_PLUGINS_PATH);
+    registry.version = registry.version || 2;
+    registry.plugins = registry.plugins || {};
+    const installInfo = {
+      scope,
+      ...scope !== "user" ? { projectPath: cwd } : {},
+      installPath: cachePath,
+      version,
+      installedAt: now,
+      lastUpdated: now,
+      gitCommitSha: ""
+    };
+    const existingEntries = registry.plugins[pluginId] || [];
+    const filteredEntries = existingEntries.filter(
+      (e) => !(e.scope === scope && (scope === "user" || e.projectPath === cwd))
+    );
+    registry.plugins[pluginId] = [...filteredEntries, installInfo];
+    await writeJson(INSTALLED_PLUGINS_PATH, registry);
+    const settingsPath = getSettingsPath(scope, cwd);
+    const settings = await readJson(settingsPath);
+    settings.enabledPlugins = settings.enabledPlugins || {};
+    settings.enabledPlugins[pluginId] = true;
+    await writeJson(settingsPath, settings);
+    spinner.succeed(
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
+    );
+    return { agent, success: true, path: cachePath };
+  } catch (error2) {
+    const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
+    spinner.fail(
+      chalk6.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
+    );
+    return { agent, success: false, path: "", error: errorMsg };
+  }
+}
+async function installPlugin(item, agents, scope, method, cwd = process.cwd()) {
+  const results = [];
+  for (const agent of agents) {
+    const result = await installPluginForAgent(item, agent, scope, method, cwd);
+    results.push(result);
+  }
+  return results;
+}
+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(
+    (key) => key.startsWith(`${slug}@`)
+  );
+  if (!matchingKey) return false;
+  const entries = registry.plugins[matchingKey] || [];
+  const filteredEntries = entries.filter(
+    (e) => !(e.scope === scope && (scope === "user" || e.projectPath === cwd))
+  );
+  if (filteredEntries.length === 0) {
+    delete registry.plugins[matchingKey];
+  } else {
+    registry.plugins[matchingKey] = filteredEntries;
+  }
+  await writeJson(INSTALLED_PLUGINS_PATH, registry);
+  const settingsPath = getSettingsPath(scope, cwd);
+  const settings = await readJson(settingsPath);
+  if (settings.enabledPlugins && matchingKey in settings.enabledPlugins) {
+    delete settings.enabledPlugins[matchingKey];
+    await writeJson(settingsPath, settings);
+  }
+  return true;
+}
+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 = [];
+  for (const [pluginId, entries] of Object.entries(registry.plugins)) {
+    for (const entry of entries) {
+      if (entry.scope === scope && (scope === "user" || entry.projectPath === cwd)) {
+        const slug = pluginId.split("@")[0] || pluginId;
+        installed.push(slug);
+        break;
+      }
+    }
+  }
+  return installed;
+}
+var pluginHandler = {
+  type: "plugin",
+  async install(item, agents, scope, method, cwd) {
+    return installPlugin(item, agents, scope, method, cwd);
+  },
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallPlugin(slug, agent, scope, cwd);
+  },
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledPlugins(agent, scope, cwd);
+  }
+};
+
+// src/handlers/index.ts
+registerHandler(skillHandler);
+registerHandler(agentHandler);
+registerHandler(hookHandler);
+registerHandler(mcpHandler);
+registerHandler(settingsHandler);
+registerHandler(pluginHandler);
+
+// src/commands/add.ts
+async function resolveItem(itemName, type) {
+  if (itemName) {
+    const item = await getItem(itemName, type);
+    if (item) return item;
+    const results = await searchItems(itemName);
+    const filtered = type ? results.filter((r) => r.type === type) : results;
+    if (filtered.length === 0) {
+      if (type && results.length > 0) {
+        const match = results.find((r) => r.slug === itemName);
+        if (match) {
+          error(`"${itemName}" is a ${match.type}, not a ${type}. Run: seedr add ${itemName} --type ${match.type}`);
+        } else {
+          error(`No ${type} matching "${itemName}". Found: ${results.map((r) => `${r.slug} (${r.type})`).join(", ")}`);
+        }
+      } else {
+        error(`"${itemName}" not found`);
+      }
+      return null;
+    }
+    if (filtered.length === 1) {
+      return filtered[0];
+    }
+    warn(`Multiple matches for "${itemName}"`);
+    const selected2 = await selectSkill(filtered);
+    if (p.isCancel(selected2)) {
+      cancelled();
+      return null;
+    }
+    return selected2;
+  }
+  const items = await listItems(type || "skill");
+  if (items.length === 0) {
+    error(`No ${type || "skill"}s available in registry`);
+    return null;
+  }
+  const selected = await selectSkill(items);
+  if (p.isCancel(selected)) {
+    cancelled();
+    return null;
+  }
+  return selected;
+}
+function resolveAgents(agentsArg, item) {
+  const typeCompatible = filterCompatibleAgents(item.type, item.compatibility);
+  if (!agentsArg) return [];
+  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 agents.filter((a) => typeCompatible.includes(a));
+  }
+  return agents;
+}
+function printDryRunSummary(item, agents, scope, method, cwd) {
+  info("Dry run - no files will be written\n");
+  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(brand("  Central storage:"));
+    console.log(`    ${chalk7.gray("\u2192")} ${chalk7.gray(centralPath)}`);
+    console.log();
+    console.log(brand("  Symlinks from agent folders:"));
+  } else {
+    console.log(brand("  Target locations:"));
+  }
+  for (const agent of agents) {
+    const config = CODING_AGENTS[agent];
+    const contentPath = getContentPath(agent, item.type, scope, cwd);
+    if (!contentPath) {
+      console.log(`    ${chalk7.gray("\u2192")} ${chalk7.white(config.name)}: ${chalk7.red("not supported")}`);
+      continue;
+    }
+    const targetPath = `${contentPath}/${item.slug}`;
+    console.log(`    ${chalk7.gray("\u2192")} ${chalk7.white(config.name)}: ${chalk7.gray(targetPath)}`);
+  }
+  console.log();
+}
+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} agent(s)`);
+    for (const r of successful) {
+      console.log(chalk7.gray(`    \u2192 ${r.path}`));
+    }
+  }
+  if (failed.length > 0) {
+    error(`Failed for ${failed.length} agent(s)`);
+    for (const r of failed) {
+      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 <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();
+    intro("Seedr");
+    const itemName = name;
+    const contentType = options.type;
+    const item = await resolveItem(itemName, contentType);
+    if (!item) process.exit(1);
+    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 agents = resolveAgents(options.agents, item);
+    const typeCompatible = filterCompatibleAgents(item.type, item.compatibility);
+    if (agents.length === 0) {
+      if (typeCompatible.length === 1) {
+        agents = typeCompatible;
+      } else {
+        const selected = await selectAgents(typeCompatible);
+        if (p.isCancel(selected)) {
+          cancelled();
+          return;
+        }
+        agents = selected;
+      }
+    }
+    if (agents.length === 0) {
+      error("No valid agents selected");
+      process.exit(1);
+    }
+    step(`Agents: ${brand(agents.join(", "))}`);
+    let scope;
+    if (options.scope) {
+      scope = options.scope;
+    } else {
+      const supportsLocal = ["plugin", "settings", "hook"].includes(item.type);
+      const selected = await selectScope(supportsLocal);
+      if (p.isCancel(selected)) {
+        cancelled();
+        return;
+      }
+      scope = selected;
+    }
+    step(`Scope: ${brand(scope)}`);
+    let method;
+    if (options.method) {
+      method = options.method;
+    } else if (agents.length === 1) {
+      method = "copy";
+    } else {
+      const symlinkPath = getAgentsPath(item.type, item.slug, process.cwd());
+      const selected = await selectMethod(symlinkPath);
+      if (p.isCancel(selected)) {
+        cancelled();
+        return;
+      }
+      method = selected;
+    }
+    step(`Method: ${brand(method)}`);
+    if (options.dryRun) {
+      console.log();
+      printDryRunSummary(item, agents, scope, method, process.cwd());
+      outro("Dry run complete");
+      return;
+    }
+    if (!options.yes) {
+      console.log();
+      const confirmed = await confirm("Proceed with installation?");
+      if (p.isCancel(confirmed) || !confirmed) {
+        cancelled();
+        return;
+      }
+    }
+    console.log();
+    const results = await handler.install(item, agents, scope, method, process.cwd());
+    trackInstalls(item.slug, item.type, results, scope);
+    printInstallSummary(results);
+    outro("Installation complete");
+  } catch (error2) {
+    handleCommandError(error2);
+  }
+});
+
+// src/commands/list.ts
+import { Command as Command2 } from "commander";
+import chalk8 from "chalk";
+var SEPARATOR_WIDTH = 40;
+var SLUG_COLUMN_WIDTH = 24;
+var TYPE_COLORS = {
+  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 {
+    if (options.installed) {
+      await listInstalled(options.scope);
+    } else {
+      await listAvailable(options.type);
+    }
+  } catch (error2) {
+    handleCommandError(error2);
+  }
+});
+async function listAvailable(type) {
+  const items = await listItems(type);
+  if (items.length === 0) {
+    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] ?? chalk8.white;
+    console.log(colorFn(`
+${itemType.toUpperCase()}S`));
+    console.log(chalk8.gray("\u2500".repeat(SEPARATOR_WIDTH)));
+    for (const item of typeItems) {
+      const compatIcons = item.compatibility.map((a) => CODING_AGENTS[a].shortName).join(" ");
+      const featured = item.featured ? chalk8.yellow("\u2605 ") : "  ";
+      console.log(
+        `${featured}${chalk8.white(item.slug.padEnd(SLUG_COLUMN_WIDTH))} ${chalk8.gray(compatIcons)}`
+      );
+      console.log(`   ${chalk8.gray(item.description)}`);
+    }
+  }
+  console.log("");
+  console.log(
+    chalk8.gray(`Total: ${items.length} items. Use 'npx @danieldeusing/seedr add <name>' to install.`)
+  );
+}
+async function listInstalled(scope) {
+  console.log(brand(`
+Installed skills (${scope} scope):
+`));
+  let total = 0;
+  for (const agent of ALL_AGENTS) {
+    const installed = await getInstalledSkills(
+      agent,
+      scope
+    );
+    if (installed.length > 0) {
+      console.log(chalk8.blue(CODING_AGENTS[agent].name));
+      for (const skill of installed) {
+        console.log(`  ${chalk8.white(skill)}`);
+        total++;
+      }
+      console.log("");
+    }
+  }
+  if (total === 0) {
+    console.log(chalk8.yellow("No skills installed"));
+  } else {
+    console.log(chalk8.gray(`Total: ${total} installed`));
+  }
+}
+function groupByType(items) {
+  return items.reduce(
+    (acc, item) => {
+      if (!acc[item.type]) {
+        acc[item.type] = [];
+      }
+      acc[item.type].push(item);
+      return acc;
+    },
+    {}
+  );
+}
+
+// src/commands/remove.ts
+import { Command as Command3 } from "commander";
+import chalk9 from "chalk";
+import ora6 from "ora";
+
+// src/utils/prompts.ts
+import inquirer from "inquirer";
+async function promptConfirm(message, defaultValue = true) {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message,
+      default: defaultValue
+    }
+  ]);
+  return confirmed;
+}
+
+// src/commands/remove.ts
+async function findInstalledAgents(slug, type, scope) {
+  const handler = getHandler(type);
+  if (!handler) return [];
+  const agents = [];
+  for (const agent of ALL_AGENTS) {
+    const installed = await handler.listInstalled(agent, scope);
+    if (installed.includes(slug)) {
+      agents.push(agent);
+    }
+  }
+  return agents;
+}
+async function removeFromAgents(slug, type, agents, scope) {
+  const handler = getHandler(type);
+  if (!handler) return 0;
+  let successCount = 0;
+  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(brand(`Removed from ${CODING_AGENTS[agent].name}`));
+      successCount++;
+    } else {
+      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 <agents>",
+  "Comma-separated coding agents or 'all'"
+).option(
+  "--scope <scope>",
+  "Installation scope: project, user, or global",
+  "project"
+).option("-y, --yes", "Skip confirmation prompts").action(async (name, options) => {
+  try {
+    const scope = options.scope;
+    const type = options.type;
+    if (!type) {
+      console.log(
+        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(chalk9.red(`No handler found for type "${type}"`));
+      process.exit(1);
+    }
+    const agents = options.agents ? parseAgentsArg(options.agents, ALL_AGENTS) : await findInstalledAgents(name, type, scope);
+    if (agents.length === 0) {
+      console.log(
+        chalk9.yellow(`${type} "${name}" is not installed in ${scope} scope`)
+      );
+      process.exit(0);
+    }
+    if (!options.yes) {
+      console.log(brand(`
+Will remove ${type} "${name}" from:`));
+      for (const agent of agents) {
+        console.log(`  - ${CODING_AGENTS[agent].name}`);
+      }
+      console.log("");
+      const confirmed = await promptConfirm("Proceed with removal?");
+      if (!confirmed) {
+        console.log(chalk9.yellow("Removal cancelled"));
+        process.exit(0);
+      }
+    }
+    const successCount = await removeFromAgents(name, type, agents, scope);
+    console.log("");
+    if (successCount > 0) {
+      console.log(
+        brand(`Successfully removed from ${successCount} agent(s)`)
+      );
+    } else {
+      console.log(chalk9.yellow("Nothing to remove"));
+    }
+  } catch (error2) {
+    handleCommandError(error2);
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command4 } from "commander";
+import chalk10 from "chalk";
+import ora7 from "ora";
+import { join as join4 } from "path";
+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 agents = parseAgentsArg(options.agents, ALL_AGENTS);
+    if (agents.length === 0) {
+      console.error(chalk10.red("No valid agents specified"));
+      process.exit(1);
+    }
+    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(chalk10.yellow("Cancelled"));
+        process.exit(0);
+      }
+    }
+    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(
+          chalk10.gray(`${CODING_AGENTS[agent].name} already initialized`)
+        );
+        continue;
+      }
+      await ensureDir(path);
+      const readmePath = join4(path, "README.md");
+      await writeTextFile(
+        readmePath,
+        `# ${CODING_AGENTS[agent].name} Configuration
+
+This directory contains AI configuration files for ${CODING_AGENTS[agent].name}.
+
+Add skills with:
+\`\`\`bash
+npx @danieldeusing/seedr add <skill-name> --agents ${agent}
+\`\`\`
+
+Browse available skills at https://seedr.danieldeusing.de
+`
+      );
+      spinner.succeed(brand(`Initialized ${CODING_AGENTS[agent].name}`));
+    }
+    console.log("");
+    console.log(
+      brand("Done! Use 'npx @danieldeusing/seedr add <skill>' to install skills.")
+    );
+  } catch (error2) {
+    handleCommandError(error2);
+  }
+});
+
+// src/cli.ts
+var program = new Command5();
+program.name("seedr").description("Seed your Coding Agents with capabilities").version("0.1.0").addCommand(addCommand).addCommand(listCommand).addCommand(removeCommand).addCommand(initCommand);
+program.action(() => {
+  printLogo();
+  program.help();
+});
+program.parse();