@toolr/seedr 0.1.0

package/dist/chunk-55GDCCIE.js

@@ -0,0 +1,438 @@
+#!/usr/bin/env node
+
+// src/config/registry.ts
+import { readFile, readdir } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var REGISTRY_PATH = join(__dirname, "../../../../registry");
+var GITHUB_RAW_URL = "https://raw.githubusercontent.com/twiced-technology-gmbh/seedr/main/registry";
+var manifestCache = {
+  data: null,
+  get() {
+    return this.data;
+  },
+  set(manifest) {
+    this.data = manifest;
+  },
+  clear() {
+    this.data = null;
+  }
+};
+async function fetchRemote(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+  }
+  return response.text();
+}
+async function loadManifest() {
+  const cached = manifestCache.get();
+  if (cached) {
+    return cached;
+  }
+  try {
+    const manifestPath = join(REGISTRY_PATH, "manifest.json");
+    const content = await readFile(manifestPath, "utf-8");
+    const manifest = JSON.parse(content);
+    manifestCache.set(manifest);
+    return manifest;
+  } catch {
+    try {
+      const content = await fetchRemote(`${GITHUB_RAW_URL}/manifest.json`);
+      const manifest = JSON.parse(content);
+      manifestCache.set(manifest);
+      return manifest;
+    } catch (error) {
+      throw new Error(
+        `Could not load registry manifest: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+}
+async function getItem(slug) {
+  const manifest = await loadManifest();
+  return manifest.items.find((item) => item.slug === slug);
+}
+async function listItems(type) {
+  const manifest = await loadManifest();
+  if (type) {
+    return manifest.items.filter((item) => item.type === type);
+  }
+  return manifest.items;
+}
+async function searchItems(query) {
+  const manifest = await loadManifest();
+  const lowerQuery = query.toLowerCase();
+  return manifest.items.filter(
+    (item) => item.slug.toLowerCase().includes(lowerQuery) || item.name.toLowerCase().includes(lowerQuery) || item.description.toLowerCase().includes(lowerQuery)
+  );
+}
+function getItemBaseUrl(item) {
+  if (item.externalUrl) {
+    const rawUrl = item.externalUrl.replace("github.com", "raw.githubusercontent.com").replace("/tree/", "/");
+    return { local: null, remote: rawUrl };
+  }
+  const typeDir = item.type + "s";
+  return {
+    local: join(REGISTRY_PATH, typeDir, item.slug),
+    remote: `${GITHUB_RAW_URL}/${typeDir}/${item.slug}`
+  };
+}
+async function getItemContent(item) {
+  const { local, remote } = getItemBaseUrl(item);
+  const mainFile = item.type === "skill" ? "SKILL.md" : `${item.type}.md`;
+  if (local) {
+    try {
+      return await readFile(join(local, mainFile), "utf-8");
+    } catch {
+    }
+  }
+  return fetchRemote(`${remote}/${mainFile}`);
+}
+function getItemSourcePath(item) {
+  if (item.sourceType !== "toolr") {
+    return null;
+  }
+  const typeDir = item.type + "s";
+  return join(REGISTRY_PATH, typeDir, item.slug);
+}
+
+// src/config/tools.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+var home = homedir();
+var SKILL_FORMAT_MARKDOWN = "markdown";
+var SKILL_EXTENSION_MD = ".md";
+var COPILOT_PATH = ".github/copilot-instructions";
+var OPENCODE_PATH = ".opencode/agents";
+var AI_TOOLS = {
+  claude: {
+    name: "Claude Code",
+    shortName: "claude",
+    projectPath: ".claude/commands",
+    userPath: join2(home, ".claude/commands"),
+    globalPath: "/Library/Application Support/ClaudeCode/commands",
+    skillFormat: SKILL_FORMAT_MARKDOWN,
+    skillExtension: SKILL_EXTENSION_MD,
+    skillDir: "commands"
+  },
+  copilot: {
+    name: "GitHub Copilot",
+    shortName: "copilot",
+    projectPath: COPILOT_PATH,
+    userPath: join2(home, COPILOT_PATH),
+    globalPath: join2(home, COPILOT_PATH),
+    skillFormat: SKILL_FORMAT_MARKDOWN,
+    skillExtension: ".instructions.md",
+    skillDir: "copilot-instructions"
+  },
+  gemini: {
+    name: "Gemini Code Assist",
+    shortName: "gemini",
+    projectPath: ".gemini",
+    userPath: join2(home, ".gemini"),
+    globalPath: join2(home, ".gemini"),
+    skillFormat: SKILL_FORMAT_MARKDOWN,
+    skillExtension: SKILL_EXTENSION_MD,
+    skillDir: ".gemini"
+  },
+  codex: {
+    name: "OpenAI Codex",
+    shortName: "codex",
+    projectPath: ".codex",
+    userPath: join2(home, ".codex"),
+    globalPath: join2(home, ".codex"),
+    skillFormat: SKILL_FORMAT_MARKDOWN,
+    skillExtension: SKILL_EXTENSION_MD,
+    skillDir: ".codex"
+  },
+  opencode: {
+    name: "OpenCode",
+    shortName: "opencode",
+    projectPath: OPENCODE_PATH,
+    userPath: join2(home, OPENCODE_PATH),
+    globalPath: join2(home, OPENCODE_PATH),
+    skillFormat: SKILL_FORMAT_MARKDOWN,
+    skillExtension: SKILL_EXTENSION_MD,
+    skillDir: "agents"
+  }
+};
+var ALL_TOOLS = Object.keys(AI_TOOLS);
+function getToolConfig(tool) {
+  return AI_TOOLS[tool];
+}
+function getToolPath(tool, scope, cwd = process.cwd()) {
+  const config = AI_TOOLS[tool];
+  switch (scope) {
+    case "project":
+      return join2(cwd, config.projectPath);
+    case "user":
+      return config.userPath;
+    case "global":
+      return config.globalPath;
+  }
+}
+
+// src/utils/fs.ts
+import {
+  access,
+  mkdir,
+  symlink,
+  copyFile,
+  readFile as readFile2,
+  writeFile,
+  unlink,
+  readlink,
+  lstat
+} from "fs/promises";
+import { dirname as dirname2, join as join3, relative, isAbsolute } from "path";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+async function installFile(source, destination, method) {
+  await ensureDir(dirname2(destination));
+  if (await exists(destination)) {
+    await unlink(destination);
+  }
+  if (method === "symlink") {
+    const relPath = relative(dirname2(destination), source);
+    await symlink(relPath, destination);
+  } else {
+    await copyFile(source, destination);
+  }
+}
+async function removeFile(path) {
+  try {
+    await unlink(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeTextFile(path, content) {
+  await ensureDir(dirname2(path));
+  await writeFile(path, content, "utf-8");
+}
+
+// src/utils/detection.ts
+async function detectInstalledTools(cwd = process.cwd()) {
+  const detected = [];
+  for (const tool of ALL_TOOLS) {
+    const projectPath = getToolPath(tool, "project", cwd);
+    if (await exists(projectPath)) {
+      detected.push({ tool, scope: "project", path: projectPath });
+    }
+    const userPath = getToolPath(tool, "user", cwd);
+    if (await exists(userPath)) {
+      detected.push({ tool, scope: "user", path: userPath });
+    }
+  }
+  return detected;
+}
+async function detectProjectTools(cwd = process.cwd()) {
+  const detected = [];
+  for (const tool of ALL_TOOLS) {
+    const projectPath = getToolPath(tool, "project", cwd);
+    if (await exists(projectPath)) {
+      detected.push(tool);
+    }
+  }
+  return detected;
+}
+async function isToolInstalled(tool, scope, cwd = process.cwd()) {
+  const path = getToolPath(tool, scope, cwd);
+  return exists(path);
+}
+function parseToolArg(arg) {
+  const normalized = arg.toLowerCase().trim();
+  if (ALL_TOOLS.includes(normalized)) {
+    return normalized;
+  }
+  const aliases = {
+    "claude-code": "claude",
+    claudecode: "claude",
+    cc: "claude",
+    "github-copilot": "copilot",
+    gh: "copilot",
+    "gemini-code": "gemini",
+    gca: "gemini",
+    "openai-codex": "codex",
+    oc: "opencode"
+  };
+  return aliases[normalized] ?? null;
+}
+function parseToolsArg(agents, allTools) {
+  if (agents === "all") {
+    return allTools;
+  }
+  return agents.split(",").map((t) => parseToolArg(t.trim())).filter((t) => t !== null);
+}
+
+// src/converters/index.ts
+import matter from "gray-matter";
+
+// src/converters/claude.ts
+var claudeConverter = {
+  convert(skill) {
+    return skill.raw;
+  }
+};
+
+// src/converters/copilot.ts
+var copilotConverter = {
+  convert(skill) {
+    return skill.raw;
+  }
+};
+
+// src/converters/gemini.ts
+var geminiConverter = {
+  convert(skill) {
+    return skill.raw;
+  }
+};
+
+// src/converters/codex.ts
+var codexConverter = {
+  convert(skill) {
+    return skill.raw;
+  }
+};
+
+// src/converters/opencode.ts
+var opencodeConverter = {
+  convert(skill) {
+    return skill.raw;
+  }
+};
+
+// src/converters/index.ts
+var converters = {
+  claude: claudeConverter,
+  copilot: copilotConverter,
+  gemini: geminiConverter,
+  codex: codexConverter,
+  opencode: opencodeConverter
+};
+function parseSkillMarkdown(content) {
+  const { data, content: body } = matter(content);
+  return {
+    frontmatter: data,
+    body: body.trim(),
+    raw: content
+  };
+}
+function convertSkillToTool(content, targetTool) {
+  const converter = converters[targetTool];
+  if (!converter) {
+    return content;
+  }
+  const skill = parseSkillMarkdown(content);
+  return converter.convert(skill);
+}
+
+// src/utils/convert.ts
+function getOutputFilename(slug, tool) {
+  const config = AI_TOOLS[tool];
+  return `${slug}${config.skillExtension}`;
+}
+
+// src/handlers/skill.ts
+import { join as join4, dirname as dirname3 } from "path";
+import chalk from "chalk";
+import ora from "ora";
+async function getSkillContent(item, tool) {
+  const canonicalContent = await getItemContent(item);
+  return convertSkillToTool(canonicalContent, tool);
+}
+async function writeSkillFile(item, _tool, content, destPath, method) {
+  const sourcePath = getItemSourcePath(item);
+  if (method === "symlink" && item.sourceType === "toolr" && sourcePath) {
+    await installFile(sourcePath, destPath, "symlink");
+  } else {
+    await ensureDir(dirname3(destPath));
+    await writeTextFile(destPath, content);
+  }
+}
+async function installSkillForTool(item, tool, scope, method, cwd) {
+  const spinner = ora(
+    `Installing ${item.name} for ${AI_TOOLS[tool].name}...`
+  ).start();
+  try {
+    const content = await getSkillContent(item, tool);
+    const destDir = getToolPath(tool, scope, cwd);
+    const filename = getOutputFilename(item.slug, tool);
+    const destPath = join4(destDir, filename);
+    await writeSkillFile(item, tool, content, destPath, method);
+    spinner.succeed(
+      chalk.green(`Installed ${item.name} for ${AI_TOOLS[tool].name}`)
+    );
+    return { tool, 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}`)
+    );
+    return { tool, success: false, path: "", error: errorMsg };
+  }
+}
+async function installSkill(item, tools, scope, method, cwd = process.cwd()) {
+  const results = [];
+  for (const tool of tools) {
+    const result = await installSkillForTool(item, tool, scope, method, cwd);
+    results.push(result);
+  }
+  return results;
+}
+async function uninstallSkill(slug, tool, scope, cwd = process.cwd()) {
+  const destDir = getToolPath(tool, scope, cwd);
+  const filename = getOutputFilename(slug, tool);
+  const destPath = join4(destDir, filename);
+  if (!await exists(destPath)) {
+    return false;
+  }
+  return removeFile(destPath);
+}
+async function getInstalledSkills(tool, scope, cwd = process.cwd()) {
+  const destDir = getToolPath(tool, scope, cwd);
+  if (!await exists(destDir)) {
+    return [];
+  }
+  const { readdir: readdir2 } = await import("fs/promises");
+  const files = await readdir2(destDir);
+  const config = AI_TOOLS[tool];
+  return files.filter((f) => f.endsWith(config.skillExtension)).map((f) => f.replace(config.skillExtension, ""));
+}
+
+export {
+  loadManifest,
+  getItem,
+  listItems,
+  searchItems,
+  getItemContent,
+  exists,
+  ensureDir,
+  writeTextFile,
+  AI_TOOLS,
+  ALL_TOOLS,
+  getToolConfig,
+  getToolPath,
+  detectInstalledTools,
+  detectProjectTools,
+  isToolInstalled,
+  parseToolsArg,
+  parseSkillMarkdown,
+  convertSkillToTool,
+  installSkill,
+  uninstallSkill,
+  getInstalledSkills
+};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+import {
+  AI_TOOLS,
+  ALL_TOOLS,
+  ensureDir,
+  exists,
+  getInstalledSkills,
+  getItem,
+  getToolPath,
+  installSkill,
+  listItems,
+  parseToolsArg,
+  searchItems,
+  uninstallSkill,
+  writeTextFile
+} from "./chunk-55GDCCIE.js";
+
+// src/cli.ts
+import { Command as Command5 } from "commander";
+import chalk6 from "chalk";
+
+// src/commands/add.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+
+// src/utils/prompts.ts
+import inquirer from "inquirer";
+async function promptSkillSelection(items) {
+  const { skill } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "skill",
+      message: "Select a skill to install:",
+      choices: items.map((item) => ({
+        name: `${item.name} - ${item.description}`,
+        value: item,
+        short: item.name
+      }))
+    }
+  ]);
+  return skill;
+}
+async function promptToolSelection(compatible) {
+  const choices = compatible.map((tool) => ({
+    name: AI_TOOLS[tool].name,
+    value: tool,
+    checked: tool === "claude"
+  }));
+  const { tools } = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "tools",
+      message: "Which AI tools do you want to install for?",
+      choices,
+      validate: (answer) => answer.length > 0 ? true : "Please select at least one tool"
+    }
+  ]);
+  return tools;
+}
+async function promptScope() {
+  const { scope } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "scope",
+      message: "Installation scope:",
+      choices: [
+        {
+          name: "Project (current directory)",
+          value: "project",
+          short: "Project"
+        },
+        { name: "User (home directory)", value: "user", short: "User" },
+        { name: "Global (system-wide)", value: "global", short: "Global" }
+      ],
+      default: "project"
+    }
+  ]);
+  return scope;
+}
+async function promptMethod() {
+  const { method } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "method",
+      message: "Installation method:",
+      choices: [
+        {
+          name: "Symlink (recommended - single source of truth)",
+          value: "symlink",
+          short: "Symlink"
+        },
+        {
+          name: "Copy (standalone copy of file)",
+          value: "copy",
+          short: "Copy"
+        }
+      ],
+      default: "symlink"
+    }
+  ]);
+  return method;
+}
+async function promptConfirm(message, defaultValue = true) {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message,
+      default: defaultValue
+    }
+  ]);
+  return confirmed;
+}
+
+// src/utils/errors.ts
+import chalk from "chalk";
+function handleCommandError(error) {
+  console.error(
+    chalk.red(`Error: ${error instanceof Error ? error.message : "Unknown error"}`)
+  );
+  process.exit(1);
+}
+
+// src/commands/add.ts
+async function resolveItem(skillName) {
+  if (skillName) {
+    const item = await getItem(skillName);
+    if (item) return item;
+    const results = await searchItems(skillName);
+    if (results.length === 0) {
+      console.error(chalk2.red(`Skill "${skillName}" not found`));
+      process.exit(1);
+    }
+    if (results.length === 1) {
+      return results[0];
+    }
+    console.log(chalk2.yellow(`Multiple matches for "${skillName}":`));
+    return promptSkillSelection(results);
+  }
+  const skills = await listItems("skill");
+  if (skills.length === 0) {
+    console.error(chalk2.red("No skills available in registry"));
+    process.exit(1);
+  }
+  return promptSkillSelection(skills);
+}
+function resolveTools(agentsArg, compatibility) {
+  if (!agentsArg) return [];
+  const tools = parseToolsArg(agentsArg, compatibility);
+  if (agentsArg === "all") return tools;
+  const incompatible = tools.filter((t) => !compatibility.includes(t));
+  if (incompatible.length > 0) {
+    console.warn(
+      chalk2.yellow(
+        `Warning: ${incompatible.join(", ")} not compatible with this skill`
+      )
+    );
+    return tools.filter((t) => compatibility.includes(t));
+  }
+  return tools;
+}
+function printInstallSummary(results) {
+  const successful = results.filter((r) => r.success);
+  const failed = results.filter((r) => !r.success);
+  console.log("");
+  if (successful.length > 0) {
+    console.log(
+      chalk2.green(`Successfully installed for ${successful.length} tool(s)`)
+    );
+    for (const r of successful) {
+      console.log(chalk2.gray(`  \u2192 ${r.path}`));
+    }
+  }
+  if (failed.length > 0) {
+    console.log(chalk2.red(`Failed for ${failed.length} tool(s)`));
+    for (const r of failed) {
+      console.log(chalk2.red(`  \xD7 ${r.tool}: ${r.error}`));
+    }
+    process.exit(1);
+  }
+}
+var addCommand = new Command("add").description("Install a skill or configuration").argument("[name]", "Name of the skill to install").option("-s, --skill <name>", "Skill name (alternative to positional arg)").option(
+  "-a, --agents <tools>",
+  "Comma-separated AI tools or 'all' (claude,copilot,gemini,codex,opencode)"
+).option(
+  "--scope <scope>",
+  "Installation scope: project, user, or global",
+  "project"
+).option(
+  "-m, --method <method>",
+  "Installation method: symlink or copy",
+  "symlink"
+).option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Overwrite existing files").action(async (name, options) => {
+  try {
+    const skillName = name ?? options.skill;
+    const item = await resolveItem(skillName);
+    console.log(
+      chalk2.blue(`
+Selected: ${item.name}`) + chalk2.gray(` - ${item.description}`)
+    );
+    let tools = resolveTools(options.agents, item.compatibility);
+    if (tools.length === 0) {
+      tools = await promptToolSelection(item.compatibility);
+    }
+    if (tools.length === 0) {
+      console.error(chalk2.red("No valid tools selected"));
+      process.exit(1);
+    }
+    const scope = options.scope ?? await promptScope();
+    const method = options.method ?? await promptMethod();
+    if (!options.yes) {
+      console.log(chalk2.cyan("\nInstallation summary:"));
+      console.log(`  Skill: ${item.name}`);
+      console.log(`  Tools: ${tools.join(", ")}`);
+      console.log(`  Scope: ${scope}`);
+      console.log(`  Method: ${method}`);
+      console.log("");
+      const confirmed = await promptConfirm("Proceed with installation?");
+      if (!confirmed) {
+        console.log(chalk2.yellow("Installation cancelled"));
+        process.exit(0);
+      }
+    }
+    const results = await installSkill(item, tools, scope, method);
+    printInstallSummary(results);
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+
+// src/commands/list.ts
+import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
+var SEPARATOR_WIDTH = 40;
+var SLUG_COLUMN_WIDTH = 24;
+var TYPE_COLORS = {
+  skill: chalk3.magenta,
+  hook: chalk3.hex("#a855f7"),
+  agent: chalk3.blue,
+  plugin: chalk3.hex("#6366f1"),
+  command: chalk3.hex("#f59e0b"),
+  settings: chalk3.hex("#f97316"),
+  mcp: chalk3.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, global)", "project").action(async (options) => {
+  try {
+    if (options.installed) {
+      await listInstalled(options.scope);
+    } else {
+      await listAvailable(options.type);
+    }
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+async function listAvailable(type) {
+  const items = await listItems(type);
+  if (items.length === 0) {
+    console.log(chalk3.yellow("No items found in registry"));
+    return;
+  }
+  const grouped = groupByType(items);
+  for (const [itemType, typeItems] of Object.entries(grouped)) {
+    const colorFn = TYPE_COLORS[itemType] ?? chalk3.white;
+    console.log(colorFn(`
+${itemType.toUpperCase()}S`));
+    console.log(chalk3.gray("\u2500".repeat(SEPARATOR_WIDTH)));
+    for (const item of typeItems) {
+      const compatIcons = item.compatibility.map((t) => AI_TOOLS[t].shortName).join(" ");
+      const featured = item.featured ? chalk3.yellow("\u2605 ") : "  ";
+      console.log(
+        `${featured}${chalk3.white(item.slug.padEnd(SLUG_COLUMN_WIDTH))} ${chalk3.gray(compatIcons)}`
+      );
+      console.log(`   ${chalk3.gray(item.description)}`);
+    }
+  }
+  console.log("");
+  console.log(
+    chalk3.gray(`Total: ${items.length} items. Use 'seedr add <name>' to install.`)
+  );
+}
+async function listInstalled(scope) {
+  console.log(chalk3.cyan(`
+Installed skills (${scope} scope):
+`));
+  let total = 0;
+  for (const tool of ALL_TOOLS) {
+    const installed = await getInstalledSkills(
+      tool,
+      scope
+    );
+    if (installed.length > 0) {
+      console.log(chalk3.blue(AI_TOOLS[tool].name));
+      for (const skill of installed) {
+        console.log(`  ${chalk3.white(skill)}`);
+        total++;
+      }
+      console.log("");
+    }
+  }
+  if (total === 0) {
+    console.log(chalk3.yellow("No skills installed"));
+  } else {
+    console.log(chalk3.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 chalk4 from "chalk";
+import ora from "ora";
+async function findInstalledTools(name, scope) {
+  const tools = [];
+  for (const tool of ALL_TOOLS) {
+    const installed = await getInstalledSkills(tool, scope);
+    if (installed.includes(name)) {
+      tools.push(tool);
+    }
+  }
+  return tools;
+}
+async function removeFromTools(name, tools, scope) {
+  let successCount = 0;
+  for (const tool of tools) {
+    const spinner = ora(`Removing from ${AI_TOOLS[tool].name}...`).start();
+    const removed = await uninstallSkill(name, tool, scope);
+    if (removed) {
+      spinner.succeed(chalk4.green(`Removed from ${AI_TOOLS[tool].name}`));
+      successCount++;
+    } else {
+      spinner.info(chalk4.gray(`Not found in ${AI_TOOLS[tool].name}`));
+    }
+  }
+  return successCount;
+}
+var removeCommand = new Command3("remove").alias("rm").description("Remove an installed skill").argument("<name>", "Name of the skill to remove").option(
+  "-a, --agents <tools>",
+  "Comma-separated AI tools 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 tools = options.agents ? parseToolsArg(options.agents, ALL_TOOLS) : await findInstalledTools(name, scope);
+    if (tools.length === 0) {
+      console.log(
+        chalk4.yellow(`Skill "${name}" is not installed in ${scope} scope`)
+      );
+      process.exit(0);
+    }
+    if (!options.yes) {
+      console.log(chalk4.cyan("\nWill remove from:"));
+      for (const tool of tools) {
+        console.log(`  - ${AI_TOOLS[tool].name}`);
+      }
+      console.log("");
+      const confirmed = await promptConfirm("Proceed with removal?");
+      if (!confirmed) {
+        console.log(chalk4.yellow("Removal cancelled"));
+        process.exit(0);
+      }
+    }
+    const successCount = await removeFromTools(name, tools, scope);
+    console.log("");
+    if (successCount > 0) {
+      console.log(
+        chalk4.green(`Successfully removed from ${successCount} tool(s)`)
+      );
+    } else {
+      console.log(chalk4.yellow("Nothing to remove"));
+    }
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command4 } from "commander";
+import chalk5 from "chalk";
+import ora2 from "ora";
+import { join } from "path";
+var initCommand = new Command4("init").description("Initialize AI tool configuration directories").option(
+  "-a, --agents <tools>",
+  "Comma-separated AI tools 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(chalk5.red("No valid tools specified"));
+      process.exit(1);
+    }
+    console.log(chalk5.cyan("\nWill initialize configuration for:"));
+    for (const tool of tools) {
+      const path = getToolPath(tool, "project");
+      console.log(`  - ${AI_TOOLS[tool].name} \u2192 ${path}`);
+    }
+    console.log("");
+    if (!options.yes) {
+      const confirmed = await promptConfirm("Proceed?");
+      if (!confirmed) {
+        console.log(chalk5.yellow("Cancelled"));
+        process.exit(0);
+      }
+    }
+    for (const tool of tools) {
+      const spinner = ora2(`Initializing ${AI_TOOLS[tool].name}...`).start();
+      const path = getToolPath(tool, "project");
+      if (await exists(path)) {
+        spinner.info(
+          chalk5.gray(`${AI_TOOLS[tool].name} already initialized`)
+        );
+        continue;
+      }
+      await ensureDir(path);
+      const readmePath = join(path, "README.md");
+      await writeTextFile(
+        readmePath,
+        `# ${AI_TOOLS[tool].name} Configuration
+
+This directory contains AI configuration files for ${AI_TOOLS[tool].name}.
+
+Add skills with:
+\`\`\`bash
+npx seedr add <skill-name> --agents ${tool}
+\`\`\`
+
+Browse available skills at https://seedr.toolr.dev
+`
+      );
+      spinner.succeed(chalk5.green(`Initialized ${AI_TOOLS[tool].name}`));
+    }
+    console.log("");
+    console.log(
+      chalk5.green("Done! Use 'seedr add <skill>' to install skills.")
+    );
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+
+// src/cli.ts
+var program = new Command5();
+program.name("seedr").description("Seed your projects with AI configurations").version("0.1.0").addCommand(addCommand).addCommand(listCommand).addCommand(removeCommand).addCommand(initCommand);
+program.action(() => {
+  console.log(
+    chalk6.green(`
+  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+  \u2551                                       \u2551
+  \u2551   \u{1F331} seedr                            \u2551
+  \u2551   Seed your projects with AI configs  \u2551
+  \u2551                                       \u2551
+  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`)
+  );
+  program.help();
+});
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,110 @@
+import { AITool, RegistryItem, ComponentType, RegistryManifest } from '@seedr/shared';
+export { AITool, ComponentType, RegistryItem, RegistryManifest } from '@seedr/shared';
+
+type InstallScope = "project" | "user" | "global";
+type InstallMethod = "symlink" | "copy";
+interface AIToolConfig {
+    name: string;
+    shortName: string;
+    projectPath: string;
+    userPath: string;
+    globalPath: string;
+    skillFormat: "markdown" | "yaml" | "json";
+    skillExtension: string;
+    skillDir: string;
+}
+interface InstallOptions {
+    skill?: string;
+    agents?: string[] | "all";
+    scope?: InstallScope;
+    method?: InstallMethod;
+    yes?: boolean;
+    force?: boolean;
+}
+interface InstalledItem {
+    slug: string;
+    type: string;
+    tool: 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" | "global", cwd?: string): string;
+
+declare function loadManifest(): Promise<RegistryManifest>;
+declare function getItem(slug: string): Promise<RegistryItem | undefined>;
+declare function listItems(type?: ComponentType): Promise<RegistryItem[]>;
+declare function searchItems(query: string): Promise<RegistryItem[]>;
+/**
+ * Fetch the main content file for an item (e.g., SKILL.md).
+ */
+declare function getItemContent(item: RegistryItem): Promise<string>;
+
+interface InstallResult {
+    tool: AITool;
+    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[]>;
+
+/**
+ * Strategy pattern interfaces for skill conversion.
+ *
+ * Each AI tool has a converter that transforms the canonical (Claude) format
+ * to the tool-specific format.
+ */
+interface SkillFrontmatter {
+    name?: string;
+    description?: string;
+    "allowed-tools"?: string[];
+    [key: string]: unknown;
+}
+interface ParsedSkill {
+    frontmatter: SkillFrontmatter;
+    body: string;
+    raw: string;
+}
+
+/**
+ * Skill Converter Registry
+ *
+ * All AI tools accept the same SKILL.md format with YAML frontmatter.
+ * Converters exist for extensibility but currently return content as-is.
+ *
+ * To add a new tool:
+ * 1. Create a new converter file (e.g., newtool.ts)
+ * 2. Implement the SkillConverter interface
+ * 3. Add it to the converters registry below
+ */
+
+/**
+ * Parse skill markdown content into frontmatter and body.
+ */
+declare function parseSkillMarkdown(content: string): ParsedSkill;
+/**
+ * Convert skill content to a specific tool format using the Strategy pattern.
+ *
+ * @param content - Raw skill content in canonical (Claude) format
+ * @param targetTool - The AI tool to convert for
+ * @returns Converted content string
+ */
+declare function convertSkillToTool(content: string, targetTool: AITool): string;
+
+interface DetectedTool {
+    tool: AITool;
+    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>;
+
+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 };

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import {
+  AI_TOOLS,
+  ALL_TOOLS,
+  convertSkillToTool,
+  detectInstalledTools,
+  detectProjectTools,
+  getInstalledSkills,
+  getItem,
+  getItemContent,
+  getToolConfig,
+  getToolPath,
+  installSkill,
+  isToolInstalled,
+  listItems,
+  loadManifest,
+  parseSkillMarkdown,
+  searchItems,
+  uninstallSkill
+} from "./chunk-55GDCCIE.js";
+export {
+  AI_TOOLS,
+  ALL_TOOLS,
+  convertSkillToTool,
+  detectInstalledTools,
+  detectProjectTools,
+  getInstalledSkills,
+  getItem,
+  getItemContent,
+  getToolConfig,
+  getToolPath,
+  installSkill,
+  isToolInstalled,
+  listItems,
+  loadManifest,
+  parseSkillMarkdown,
+  searchItems,
+  uninstallSkill
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@toolr/seedr",
+  "version": "0.1.0",
+  "description": "Seed your projects with AI configurations",
+  "type": "module",
+  "bin": {
+    "seedr": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@seedr/shared": "workspace:*",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "fs-extra": "^11.2.0",
+    "gray-matter": "^4.0.3",
+    "inquirer": "^12.3.0",
+    "ora": "^8.1.1",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "keywords": [
+    "ai",
+    "claude",
+    "copilot",
+    "gemini",
+    "codex",
+    "opencode",
+    "configuration",
+    "seeder"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/twiced-technology-gmbh/seedr.git"
+  },
+  "homepage": "https://seedr.toolr.dev",
+  "bugs": {
+    "url": "https://github.com/twiced-technology-gmbh/seedr/issues"
+  },
+  "license": "MIT"
+}