@danieldeusing/seedr 0.1.97 → 0.1.99

package/dist/{chunk-PEGEA2KN.js → chunk-3KPB5CCX.js}

@@ -18,7 +18,7 @@ function registryDirName(config) {
   }
   return value;
 }
-var ALL_TYPES = ["skill", "plugin", "hook", "agent", "mcp", "settings", "command"];
+var ALL_TYPES = ["skill", "plugin", "hook", "agent", "mcp", "settings", "command", "rule"];
 var KNOWN_TYPES = new Set(ALL_TYPES);
 function typeDirName(type) {
   return type === "settings" || type === "mcp" ? type : `${type}s`;
@@ -46,6 +46,23 @@ function canonicalAgents(values) {
   const present = new Set(values.map(canonicalAgent).filter((a) => a !== null));
   return CANONICAL_AGENTS.filter((a) => present.has(a));
 }
+var AGENT_COMPATIBILITY = {
+  skill: ["claude", "copilot", "antigravity", "codex", "opencode"],
+  command: ["claude"],
+  // Copilot's subagent files carry the same name/description frontmatter.
+  // OpenCode's do not — theirs use `mode` and a `tools` map — so porting there
+  // needs a frontmatter translation, not a path.
+  agent: ["claude", "copilot"],
+  hook: ["claude"],
+  plugin: ["claude", "copilot", "antigravity", "codex", "opencode"],
+  settings: ["claude"],
+  mcp: ["claude", "codex", "opencode", "copilot"],
+  rule: ["claude", "copilot", "antigravity", "codex", "opencode"]
+};
+function isTypeSupported(type, agent) {
+  const canonical = canonicalAgent(agent);
+  return canonical !== null && AGENT_COMPATIBILITY[type].includes(canonical);
+}
 
 // ../registry-ops/src/sourceTypes.ts
 var CANONICAL_SOURCE_TYPES = ["official", "seedr", "community"];
@@ -756,17 +773,35 @@ async function fetchItemToDestination(item, destPath) {
 }
 
 // src/config/agents.ts
+import { existsSync as existsSync12 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join14 } from "path";
 var home = homedir2();
+function claudeUserJsonPath() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR;
+  if (configDir) {
+    const scoped = join14(configDir, ".config.json");
+    if (existsSync12(scoped)) return scoped;
+  }
+  return join14(configDir || home, ".claude.json");
+}
+var copilotUserRoot = () => process.env.COPILOT_HOME || join14(home, ".copilot");
+var codexUserRoot = () => process.env.CODEX_HOME || join14(home, ".codex");
+var openCodeUserConfigDir = () => process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join14(process.env.XDG_CONFIG_HOME, "opencode") : join14(home, ".config", "opencode"));
+var claudeUserRoot = () => process.env.CLAUDE_CONFIG_DIR || join14(home, ".claude");
 var SKILL_DIRECTORY = {
   path: "skills"
 };
 var ANTIGRAVITY = {
   name: "Google Antigravity",
   shortName: "antigravity",
+  // Project content is the agent-neutral `.agents/` tree, which IS Antigravity's
+  // own project root. The personal tier is not the same spelling: the shipped
+  // CLI reads `~/.gemini/config/skills`, and the vendor documentation states
+  // outright that `~/.agents` does not exist for it. `~/.gemini/skills` is the
+  // predecessor Gemini CLI location and is not written.
   projectRoot: ".agents",
-  userRoot: join14(home, ".agents"),
+  userRoot: join14(home, ".gemini", "config"),
   contentTypes: { skill: SKILL_DIRECTORY }
 };
 var CODING_AGENTS = {
@@ -774,7 +809,7 @@ var CODING_AGENTS = {
     name: "Claude Code",
     shortName: "claude",
     projectRoot: ".claude",
-    userRoot: join14(home, ".claude"),
+    userRoot: claudeUserRoot(),
     contentTypes: {
       skill: SKILL_DIRECTORY,
       command: {
@@ -800,9 +835,15 @@ var CODING_AGENTS = {
   copilot: {
     name: "GitHub Copilot",
     shortName: "copilot",
+    // Project content is `.github/`, but the personal tier is `~/.copilot/` —
+    // the two are not the same spelling. `~/.github/skills` is read by nothing;
+    // `~/.copilot/skills` is what the CLI itself populates.
     projectRoot: ".github",
-    userRoot: join14(home, ".github"),
-    contentTypes: { skill: SKILL_DIRECTORY }
+    userRoot: copilotUserRoot(),
+    // Subagents are `<name>.agent.md` under `agents/`, with the same
+    // `name` + `description` frontmatter a Claude subagent carries — confirmed
+    // from files on a real machine.
+    contentTypes: { skill: SKILL_DIRECTORY, agent: { path: "agents" } }
   },
   antigravity: ANTIGRAVITY,
   gemini: ANTIGRAVITY,
@@ -810,14 +851,19 @@ var CODING_AGENTS = {
     name: "OpenAI Codex CLI",
     shortName: "codex",
     projectRoot: ".codex",
-    userRoot: join14(home, ".codex"),
+    userRoot: codexUserRoot(),
     contentTypes: { skill: SKILL_DIRECTORY }
   },
   opencode: {
     name: "OpenCode",
     shortName: "opencode",
+    // `~/.opencode` is the LEGACY user directory. The global config directory
+    // is `~/.config/opencode`, which is where this package already writes
+    // `opencode.json` and `AGENTS.md` — splitting one agent across two roots
+    // made `list` and `remove` diverge, and creating `~/.opencode` on a machine
+    // that had none adds a capability directory ranked above every project one.
     projectRoot: ".opencode",
-    userRoot: join14(home, ".opencode"),
+    userRoot: openCodeUserConfigDir(),
     contentTypes: { skill: SKILL_DIRECTORY }
   }
 };
@@ -849,7 +895,7 @@ function getSettingsPath(scope, cwd = process.cwd()) {
     case "project":
       return join14(cwd, ".claude/settings.json");
     case "user":
-      return join14(home, ".claude/settings.json");
+      return join14(claudeUserRoot(), "settings.json");
     case "local":
       return join14(cwd, ".claude/settings.local.json");
   }
@@ -858,11 +904,13 @@ function getMcpConfigPath(agent, scope, cwd = process.cwd()) {
   const isUser = scope === "user";
   switch (canonicalAgent(agent) ?? agent) {
     case "claude":
-      return isUser ? join14(home, ".claude.json") : join14(cwd, ".mcp.json");
+      return isUser ? claudeUserJsonPath() : join14(cwd, ".mcp.json");
     case "codex":
-      return isUser ? join14(home, ".codex", "config.toml") : join14(cwd, ".codex", "config.toml");
+      return isUser ? join14(codexUserRoot(), "config.toml") : join14(cwd, ".codex", "config.toml");
     case "opencode":
-      return isUser ? join14(home, ".config", "opencode", "opencode.json") : join14(cwd, "opencode.json");
+      return isUser ? join14(openCodeUserConfigDir(), "opencode.json") : join14(cwd, "opencode.json");
+    case "copilot":
+      return isUser ? join14(copilotUserRoot(), "mcp-config.json") : join14(cwd, ".mcp.json");
     default:
       throw new Error(`${agent} has no verified MCP configuration format`);
   }
@@ -1041,18 +1089,94 @@ function error(message) {
 }
 
 // src/handlers/skill.ts
-import { relative as relative5, dirname as dirname7 } from "path";
+import { relative as relative5, dirname as dirname8, join as join15 } from "path";
 import { homedir as homedir3 } from "os";
 import { readdir as readdir2, symlink as symlink2 } from "fs/promises";
 import chalk2 from "chalk";
 import ora from "ora";
+
+// src/utils/json.ts
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import { dirname as dirname7 } from "path";
+async function readJson(path) {
+  try {
+    const content = await readFile4(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error2) {
+    if (error2.code === "ENOENT") {
+      return {};
+    }
+    if (error2 instanceof SyntaxError) {
+      throw new Error(`${path} is not valid JSON: ${error2.message}`, { cause: error2 });
+    }
+    throw error2;
+  }
+}
+async function existingFileMode(path) {
+  try {
+    return (await stat2(path)).mode & 511;
+  } catch (error2) {
+    if (error2.code === "ENOENT") return void 0;
+    throw error2;
+  }
+}
+async function writeJson(path, data) {
+  await ensureDir(dirname7(path));
+  const mode = await existingFileMode(path);
+  await writeFileAtomic(path, JSON.stringify(data, null, 2) + "\n", { mode });
+}
+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/skill.ts
 var SLUG_LABEL = "skill slug";
-var READS_CENTRAL_DIR = /* @__PURE__ */ new Set(["antigravity", "codex", "opencode"]);
+function readsCentralDir(agent, scope) {
+  const canonical = canonicalAgent(agent) ?? agent;
+  if (canonical === "antigravity") return scope !== "user";
+  return canonical === "codex" || canonical === "opencode";
+}
+var OWNERS_FILE = ".seedr-central-owners.json";
+async function readOwners(scope, cwd) {
+  return readJson(join15(centralSkillsDir(scope, cwd), OWNERS_FILE));
+}
+async function writeOwners(owners, scope, cwd) {
+  await writeJson(join15(centralSkillsDir(scope, cwd), OWNERS_FILE), owners);
+}
+async function addOwners(slug, agents, scope, cwd) {
+  if (agents.length === 0) return;
+  const owners = await readOwners(scope, cwd);
+  owners[slug] = [.../* @__PURE__ */ new Set([...owners[slug] ?? [], ...agents])];
+  await writeOwners(owners, scope, cwd);
+}
+async function dropOwner(slug, agent, scope, cwd) {
+  const owners = await readOwners(scope, cwd);
+  const recorded = owners[slug];
+  if (!recorded) return [];
+  const remaining = recorded.filter((owner) => owner !== (canonicalAgent(agent) ?? agent));
+  if (remaining.length > 0) owners[slug] = remaining;
+  else delete owners[slug];
+  await writeOwners(owners, scope, cwd);
+  return remaining;
+}
 function getScopeRoot(scope, cwd) {
   return scope === "user" ? homedir3() : cwd;
 }
 function centralSkillsDir(scope, cwd) {
-  return dirname7(getAgentsPath("skill", "any-slug", scope, cwd));
+  return dirname8(getAgentsPath("skill", "any-slug", scope, cwd));
 }
 async function resolveCentralPath(slug, scope, cwd) {
   const scopeRoot = getScopeRoot(scope, cwd);
@@ -1077,9 +1201,9 @@ async function installToCentralLocation(item, sourcePath, scope, force, cwd) {
   return { centralPath, created: !existed };
 }
 async function createAgentSymlink(centralPath, destPath) {
-  await ensureDir(dirname7(destPath));
+  await ensureDir(dirname8(destPath));
   await removePathEntry(destPath);
-  const relPath = relative5(dirname7(destPath), centralPath);
+  const relPath = relative5(dirname8(destPath), centralPath);
   await symlink2(relPath, destPath);
 }
 async function installSkillForAgent(item, agent, scope, method, force, cwd, centralPath) {
@@ -1121,7 +1245,7 @@ async function installSkill(item, agents, scope, method, force, cwd = process.cw
     central = await installToCentralLocation(item, sourcePath, scope, force, cwd);
   }
   for (const agent of agents) {
-    if (READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent) && central) {
+    if (readsCentralDir(agent, scope) && central) {
       results.push({ agent, success: true, path: central.centralPath });
       continue;
     }
@@ -1138,15 +1262,30 @@ async function installSkill(item, agents, scope, method, force, cwd = process.cw
   }
   if (central?.created && !results.some((result) => result.success)) {
     await removePathEntry(central.centralPath);
+    return results;
+  }
+  if (central) {
+    const centralReaders = agents.filter(
+      (agent) => readsCentralDir(agent, scope) && results.some((result) => result.agent === agent && result.success)
+    );
+    await addOwners(item.slug, centralReaders, scope, cwd);
   }
   return results;
 }
 async function uninstallSkill(slug, agent, scope, cwd = process.cwd()) {
   assertValidSlug(slug, SLUG_LABEL);
+  const central = await resolveCentralPath(slug, scope, cwd);
   const destPath = await resolveAgentSkillPath(agent, slug, scope, cwd);
-  if (destPath && await removePathEntry(destPath)) return true;
-  if (READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent)) {
-    return removePathEntry(await resolveCentralPath(slug, scope, cwd));
+  if (readsCentralDir(agent, scope) || destPath === central) {
+    const remaining = await dropOwner(slug, agent, scope, cwd);
+    if (remaining.length > 0) {
+      return true;
+    }
+    return removePathEntry(central);
+  }
+  if (destPath && await removePathEntry(destPath)) {
+    await dropOwner(slug, agent, scope, cwd);
+    return true;
   }
   return false;
 }
@@ -1154,13 +1293,21 @@ async function getInstalledSkills(agent, scope, cwd = process.cwd()) {
   const dirs = /* @__PURE__ */ new Set();
   const own = getContentPath(agent, "skill", scope, cwd);
   if (own) dirs.add(own);
-  if (READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent)) dirs.add(centralSkillsDir(scope, cwd));
+  if (readsCentralDir(agent, scope)) dirs.add(centralSkillsDir(scope, cwd));
+  const owners = await readOwners(scope, cwd);
+  const centralDir = centralSkillsDir(scope, cwd);
+  const canonical = canonicalAgent(agent) ?? agent;
+  const isInstalledHere = (entry, dir) => {
+    if (entry.name.startsWith(".")) return false;
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) return false;
+    const recorded = dir === centralDir ? owners[entry.name] : void 0;
+    return !recorded || recorded.includes(canonical);
+  };
   const slugs = /* @__PURE__ */ new Set();
   for (const dir of dirs) {
     if (!await exists(dir)) continue;
-    const entries = await readdir2(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if ((entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith(".")) slugs.add(entry.name);
+    for (const entry of await readdir2(dir, { withFileTypes: true })) {
+      if (isInstalledHere(entry, dir)) slugs.add(entry.name);
     }
   }
   return [...slugs];
@@ -1172,7 +1319,7 @@ async function planSkill(item, agents, scope, method, cwd) {
   let centralPath;
   if (method === "symlink") {
     centralPath = await resolveCentralPath(item.slug, scope, cwd);
-    const sharedBy = agents.filter((agent) => READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent));
+    const sharedBy = agents.filter((agent) => readsCentralDir(agent, scope));
     changes.push({
       agent: "shared",
       kind: await kindFor(centralPath),
@@ -1181,7 +1328,7 @@ async function planSkill(item, agents, scope, method, cwd) {
     });
   }
   for (const agent of agents) {
-    if (centralPath && READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent)) continue;
+    if (centralPath && readsCentralDir(agent, scope)) continue;
     const destPath = await resolveAgentSkillPath(agent, item.slug, scope, cwd);
     if (!destPath) throw new Error(`${CODING_AGENTS[agent].name} does not support skills`);
     changes.push({
@@ -1208,10 +1355,13 @@ var skillHandler = {
 };
 
 export {
+  ALL_TYPES,
   mainFileName,
   isLegacyAgent,
   canonicalAgent,
   canonicalAgents,
+  AGENT_COMPATIBILITY,
+  isTypeSupported,
   SLUG_PATTERN2 as SLUG_PATTERN,
   MAX_SLUG_LENGTH2 as MAX_SLUG_LENGTH,
   isValidSlug2 as isValidSlug,
@@ -1242,6 +1392,10 @@ export {
   fetchItemFile,
   getItemSourcePath,
   fetchItemToDestination,
+  copilotUserRoot,
+  codexUserRoot,
+  openCodeUserConfigDir,
+  claudeUserRoot,
   CODING_AGENTS,
   ALL_AGENTS,
   getAgentConfig,
@@ -1269,6 +1423,9 @@ export {
   success,
   warn,
   error,
+  readJson,
+  writeJson,
+  deepMerge,
   installSkill,
   uninstallSkill,
   getInstalledSkills,