@danieldeusing/seedr 0.1.80

package/dist/chunk-5XFKC3T7.js

@@ -0,0 +1,681 @@
+#!/usr/bin/env node
+
+// src/config/registry.ts
+import { readFile, readdir, writeFile, mkdir } 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/danieldeusing/seedr/main/registry";
+var cache = {
+  index: null,
+  types: /* @__PURE__ */ new Map(),
+  assembled: null
+};
+async function loadFile(filename) {
+  try {
+    return await readFile(join(REGISTRY_PATH, filename), "utf-8");
+  } catch {
+    return fetchRemote(`${GITHUB_RAW_URL}/${filename}`);
+  }
+}
+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 loadIndex() {
+  if (cache.index) return cache.index;
+  const content = await loadFile("manifest.json");
+  const data = JSON.parse(content);
+  cache.index = data;
+  return data;
+}
+async function loadTypeItems(type) {
+  const cached = cache.types.get(type);
+  if (cached) return cached;
+  const index = await loadIndex();
+  const desc = index.types[type];
+  const content = await loadFile(desc.file);
+  const typeManifest = JSON.parse(content);
+  cache.types.set(type, typeManifest.items);
+  return typeManifest.items;
+}
+async function loadManifest() {
+  if (cache.assembled) return cache.assembled;
+  const index = await loadIndex();
+  const typeEntries = Object.entries(index.types);
+  const typeResults = await Promise.all(
+    typeEntries.map(async ([type]) => loadTypeItems(type))
+  );
+  const items = typeResults.flat();
+  const manifest = { version: index.version, items };
+  cache.assembled = manifest;
+  return manifest;
+}
+async function getItem(slug, type) {
+  const manifest = await loadManifest();
+  if (type) return manifest.items.find((item) => item.slug === slug && item.type === type);
+  return manifest.items.find((item) => item.slug === slug);
+}
+async function listItems(type) {
+  if (type) {
+    return loadTypeItems(type);
+  }
+  const manifest = await loadManifest();
+  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)
+  );
+}
+async function getItemFull(item) {
+  const typeDir = item.type + "s";
+  const itemJsonPath = `${typeDir}/${item.slug}/item.json`;
+  const content = await loadFile(itemJsonPath);
+  return JSON.parse(content);
+}
+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);
+}
+async function fetchItemToDestination(item, destPath) {
+  const { remote } = getItemBaseUrl(item);
+  let files = item.contents?.files;
+  if (!files && item.type === "plugin") {
+    const full = await getItemFull(item);
+    files = full.contents?.files;
+  }
+  if (files) {
+    await mkdir(destPath, { recursive: true });
+    await fetchFileTree(files, remote, destPath);
+    return;
+  }
+  const filesToFetch = item.type === "skill" ? ["SKILL.md"] : item.type === "plugin" ? [".claude-plugin/plugin.json"] : [`${item.type}.md`];
+  await mkdir(destPath, { recursive: true });
+  await Promise.all(filesToFetch.map(async (file) => {
+    const content = await fetchRemote(`${remote}/${file}`);
+    const filePath = join(destPath, file);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf-8");
+  }));
+}
+async function fetchFileTree(nodes, baseUrl, destPath) {
+  await Promise.all(nodes.map(async (node) => {
+    const nodePath = join(destPath, node.name);
+    if (node.type === "directory") {
+      await mkdir(nodePath, { recursive: true });
+      if (node.children) {
+        await fetchFileTree(node.children, `${baseUrl}/${node.name}`, nodePath);
+      }
+    } else {
+      const content = await fetchRemote(`${baseUrl}/${node.name}`);
+      await writeFile(nodePath, content, "utf-8");
+    }
+  }));
+}
+
+// src/config/agents.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+var home = homedir();
+var CODING_AGENTS = {
+  claude: {
+    name: "Claude Code",
+    shortName: "claude",
+    projectRoot: ".claude",
+    userRoot: join2(home, ".claude"),
+    contentTypes: {
+      skill: {
+        path: "skills",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "SKILL.md"
+      },
+      command: {
+        path: "commands",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "COMMAND.md"
+      },
+      agent: {
+        path: "agents",
+        extension: ".md",
+        structure: "file"
+      },
+      hook: {
+        path: "",
+        extension: ".json",
+        structure: "json-merge",
+        mergeTarget: "settings.json",
+        mergeField: "hooks"
+      },
+      plugin: {
+        path: "plugins/cache",
+        extension: "",
+        structure: "plugin"
+      },
+      settings: {
+        path: "",
+        extension: ".json",
+        structure: "json-merge",
+        mergeTarget: "settings.json"
+      },
+      mcp: {
+        path: "",
+        extension: ".json",
+        structure: "json-merge",
+        mergeTarget: ".mcp.json",
+        mergeField: "mcpServers"
+      }
+    }
+  },
+  copilot: {
+    name: "GitHub Copilot",
+    shortName: "copilot",
+    projectRoot: ".github",
+    userRoot: join2(home, ".github"),
+    contentTypes: {
+      skill: {
+        path: "skills",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "SKILL.md"
+      }
+    }
+  },
+  gemini: {
+    name: "Gemini Code Assist",
+    shortName: "gemini",
+    projectRoot: ".gemini",
+    userRoot: join2(home, ".gemini"),
+    contentTypes: {
+      skill: {
+        path: "skills",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "SKILL.md"
+      }
+    }
+  },
+  codex: {
+    name: "OpenAI Codex CLI",
+    shortName: "codex",
+    projectRoot: ".codex",
+    userRoot: join2(home, ".codex"),
+    contentTypes: {
+      skill: {
+        path: "skills",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "SKILL.md"
+      }
+    }
+  },
+  opencode: {
+    name: "OpenCode",
+    shortName: "opencode",
+    projectRoot: ".opencode",
+    userRoot: join2(home, ".opencode"),
+    contentTypes: {
+      skill: {
+        path: "skills",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "SKILL.md"
+      }
+    }
+  }
+};
+var ALL_AGENTS = Object.keys(CODING_AGENTS);
+function getAgentConfig(agent) {
+  return CODING_AGENTS[agent];
+}
+function getContentTypeConfig(agent, type) {
+  return CODING_AGENTS[agent].contentTypes[type];
+}
+function getAgentRoot(agent, scope, cwd = process.cwd()) {
+  const config = CODING_AGENTS[agent];
+  switch (scope) {
+    case "project":
+    case "local":
+      return join2(cwd, config.projectRoot);
+    case "user":
+      return config.userRoot;
+  }
+}
+function getContentPath(agent, type, scope, cwd = process.cwd()) {
+  const typeConfig = getContentTypeConfig(agent, type);
+  if (!typeConfig) return void 0;
+  const root = getAgentRoot(agent, scope, cwd);
+  return typeConfig.path ? join2(root, typeConfig.path) : root;
+}
+function getSettingsPath(scope, cwd = process.cwd()) {
+  switch (scope) {
+    case "project":
+      return join2(cwd, ".claude/settings.json");
+    case "user":
+      return join2(home, ".claude/settings.json");
+    case "local":
+      return join2(cwd, ".claude/settings.local.json");
+  }
+}
+function getMcpPath(scope, cwd = process.cwd()) {
+  switch (scope) {
+    case "project":
+    case "local":
+      return join2(cwd, ".mcp.json");
+    case "user":
+      return join2(home, ".claude.json");
+  }
+}
+function getAgentPath(agent, scope, cwd = process.cwd()) {
+  return getContentPath(agent, "skill", scope, cwd) || "";
+}
+
+// src/utils/fs.ts
+import {
+  access,
+  mkdir as mkdir2,
+  symlink,
+  copyFile,
+  readFile as readFile2,
+  writeFile as writeFile2,
+  unlink,
+  readlink,
+  lstat,
+  cp,
+  rm
+} 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 mkdir2(path, { recursive: true });
+}
+async function installFile(source, destination, method) {
+  await ensureDir(dirname2(destination));
+  try {
+    await unlink(destination);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  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 writeFile2(path, content, "utf-8");
+}
+function getAgentsPath(contentType, slug, cwd) {
+  return join3(cwd, ".agents", contentType + "s", slug);
+}
+async function copyDirectory(source, destination) {
+  await cp(source, destination, { recursive: true });
+}
+async function installDirectory(source, destination, method) {
+  await ensureDir(dirname2(destination));
+  await rm(destination, { recursive: true, force: true });
+  if (method === "symlink") {
+    const relPath = relative(dirname2(destination), source);
+    await symlink(relPath, destination);
+  } else {
+    await copyDirectory(source, destination);
+  }
+}
+
+// src/utils/detection.ts
+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 ? { 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 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((a) => a !== null);
+}
+async function isAgentInstalled(agent, scope, cwd = process.cwd()) {
+  const effectiveScope = scope === "local" ? "project" : scope;
+  const path = getAgentPath(agent, effectiveScope, cwd);
+  return exists(path);
+}
+function parseAgentArg(arg) {
+  const normalized = arg.toLowerCase().trim();
+  if (ALL_AGENTS.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 parseAgentsArg(agents, allAgents) {
+  if (agents === "all") {
+    return allAgents;
+  }
+  return agents.split(",").map((a) => parseAgentArg(a.trim())).filter((a) => a !== null);
+}
+
+// src/utils/ui.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+var brand = chalk.hex("#22c55e");
+var bgBrand = chalk.bgHex("#22c55e").black;
+var LOGO = `
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D`;
+var URLS = {
+  seedr: "https://seedr.danieldeusing.de"
+};
+function printLogo() {
+  console.log(brand(LOGO));
+  console.log(brand("  \u{1F331} Seed your Coding Agents with capabilities"));
+  console.log(chalk.gray(`  ${URLS.seedr}`));
+  console.log();
+}
+async function selectSkill(items) {
+  const result = await p.select({
+    message: "Select a skill to install",
+    options: items.map((item) => ({
+      label: item.name,
+      value: item,
+      hint: item.description
+    }))
+  });
+  return result;
+}
+async function selectAgents(compatible) {
+  const allOption = await p.select({
+    message: "Which coding agents do you want to install for?",
+    options: [
+      { label: `All (${compatible.length} agents)`, value: "all" },
+      { label: "Select specific agents...", value: "select" }
+    ]
+  });
+  if (p.isCancel(allOption)) return allOption;
+  if (allOption === "all") return compatible;
+  const result = await p.multiselect({
+    message: "Select agents",
+    options: compatible.map((agent) => ({
+      label: CODING_AGENTS[agent].name,
+      value: agent,
+      hint: CODING_AGENTS[agent].projectRoot
+    })),
+    initialValues: ["claude"],
+    required: true
+  });
+  return result;
+}
+async function selectScope(includeLocal = false) {
+  const options = [
+    { label: "Project", value: "project", hint: includeLocal ? "current directory, settings.json" : "current directory" },
+    { label: "User", value: "user", hint: "home directory" },
+    ...includeLocal ? [{ label: "Local", value: "local", hint: "current directory, settings.local.json" }] : []
+  ];
+  const result = await p.select({ message: "Installation scope", options });
+  return result;
+}
+async function selectMethod(symlinkPath) {
+  const result = await p.select({
+    message: "Installation method",
+    options: [
+      { label: "Symlink", value: "symlink", hint: `shared at ${symlinkPath}` },
+      { label: "Copy", value: "copy", hint: "standalone copy per agent" }
+    ]
+  });
+  return result;
+}
+async function confirm2(message) {
+  return p.confirm({ message });
+}
+function cancelled() {
+  p.cancel("Operation cancelled");
+  process.exit(0);
+}
+function intro2(message) {
+  p.intro(bgBrand(` ${message} `));
+}
+function outro2(message) {
+  p.outro(brand(message));
+}
+function step(message) {
+  p.log.step(message);
+}
+function info(message) {
+  p.log.info(message);
+}
+function success(message) {
+  p.log.success(message);
+}
+function warn(message) {
+  p.log.warn(message);
+}
+function error(message) {
+  p.log.error(message);
+}
+
+// src/handlers/skill.ts
+import { join as join4, relative as relative2, dirname as dirname3 } from "path";
+import { readdir as readdir2, symlink as symlink2, rm as rm2 } from "fs/promises";
+import chalk2 from "chalk";
+import ora from "ora";
+async function installToCentralLocation(item, sourcePath, cwd) {
+  const centralPath = getAgentsPath("skill", item.slug, cwd);
+  await rm2(centralPath, { recursive: true, force: true });
+  if (sourcePath && await exists(sourcePath)) {
+    await copyDirectory(sourcePath, centralPath);
+  } else {
+    await fetchItemToDestination(item, centralPath);
+  }
+  return centralPath;
+}
+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 installSkillForAgent(item, agent, scope, method, cwd, centralPath) {
+  const spinner = ora(
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
+  ).start();
+  try {
+    const destDir = getContentPath(agent, "skill", scope, cwd);
+    if (!destDir) {
+      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 createAgentSymlink(centralPath, destPath);
+    } else if (sourcePath && await exists(sourcePath)) {
+      await installDirectory(sourcePath, destPath, "copy");
+    } else {
+      await fetchItemToDestination(item, destPath);
+    }
+    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 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 agent of agents) {
+    const readsAgentsDir = agent === "gemini" || agent === "codex" || agent === "opencode";
+    if (readsAgentsDir && method === "symlink" && centralPath) {
+      results.push({ agent, success: true, path: centralPath });
+      continue;
+    }
+    const result = await installSkillForAgent(
+      item,
+      agent,
+      scope,
+      method,
+      cwd,
+      centralPath
+    );
+    results.push(result);
+  }
+  return results;
+}
+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)) {
+    return false;
+  }
+  await rm2(destPath, { recursive: true });
+  return true;
+}
+async function getInstalledSkills(agent, scope, cwd = process.cwd()) {
+  const destDir = getContentPath(agent, "skill", scope, cwd);
+  if (!destDir || !await exists(destDir)) {
+    return [];
+  }
+  const entries = await readdir2(destDir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}
+var skillHandler = {
+  type: "skill",
+  async install(item, agents, scope, method, cwd) {
+    return installSkill(item, agents, scope, method, cwd);
+  },
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallSkill(slug, agent, scope, cwd);
+  },
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledSkills(agent, scope, cwd);
+  }
+};
+
+export {
+  loadManifest,
+  getItem,
+  listItems,
+  searchItems,
+  getItemContent,
+  getItemSourcePath,
+  fetchItemToDestination,
+  exists,
+  ensureDir,
+  installFile,
+  removeFile,
+  writeTextFile,
+  getAgentsPath,
+  installDirectory,
+  CODING_AGENTS,
+  ALL_AGENTS,
+  getAgentConfig,
+  getContentPath,
+  getSettingsPath,
+  getMcpPath,
+  getAgentPath,
+  detectInstalledAgents,
+  detectProjectAgents,
+  isAgentInstalled,
+  parseAgentsArg,
+  p,
+  brand,
+  printLogo,
+  selectSkill,
+  selectAgents,
+  selectScope,
+  selectMethod,
+  confirm2 as confirm,
+  cancelled,
+  intro2 as intro,
+  outro2 as outro,
+  step,
+  info,
+  success,
+  warn,
+  error,
+  installSkill,
+  uninstallSkill,
+  getInstalledSkills,
+  skillHandler
+};

package/dist/cli.d.ts

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