@toolr/seedr 0.1.0 → 0.1.3

package/dist/{chunk-55GDCCIE.js → chunk-7GIETJRD.js}

@@ -102,77 +102,159 @@ function getItemSourcePath(item) {
 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"
+    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",
-    projectPath: COPILOT_PATH,
-    userPath: join2(home, COPILOT_PATH),
-    globalPath: join2(home, COPILOT_PATH),
-    skillFormat: SKILL_FORMAT_MARKDOWN,
-    skillExtension: ".instructions.md",
-    skillDir: "copilot-instructions"
+    projectRoot: ".github",
+    userRoot: join2(home, ".github"),
+    contentTypes: {
+      skill: {
+        path: "skills",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "SKILL.md"
+      }
+    }
   },
   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"
+    projectRoot: ".gemini",
+    userRoot: join2(home, ".gemini"),
+    contentTypes: {
+      skill: {
+        path: "skills",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "SKILL.md"
+      }
+    }
   },
   codex: {
-    name: "OpenAI Codex",
+    name: "OpenAI Codex CLI",
     shortName: "codex",
-    projectPath: ".codex",
-    userPath: join2(home, ".codex"),
-    globalPath: join2(home, ".codex"),
-    skillFormat: SKILL_FORMAT_MARKDOWN,
-    skillExtension: SKILL_EXTENSION_MD,
-    skillDir: ".codex"
+    projectRoot: ".codex",
+    userRoot: join2(home, ".codex"),
+    contentTypes: {
+      skill: {
+        path: "skills",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "SKILL.md"
+      }
+    }
   },
   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"
+    projectRoot: ".opencode",
+    userRoot: join2(home, ".opencode"),
+    contentTypes: {
+      skill: {
+        path: "skills",
+        extension: ".md",
+        structure: "directory",
+        mainFile: "SKILL.md"
+      }
+    }
   }
 };
 var ALL_TOOLS = Object.keys(AI_TOOLS);
 function getToolConfig(tool) {
   return AI_TOOLS[tool];
 }
-function getToolPath(tool, scope, cwd = process.cwd()) {
+function getContentTypeConfig(tool, type) {
+  return AI_TOOLS[tool].contentTypes[type];
+}
+function getToolRoot(tool, scope, cwd = process.cwd()) {
   const config = AI_TOOLS[tool];
   switch (scope) {
     case "project":
-      return join2(cwd, config.projectPath);
+    case "local":
+      return join2(cwd, config.projectRoot);
     case "user":
-      return config.userPath;
-    case "global":
-      return config.globalPath;
+      return config.userRoot;
   }
 }
+function getContentPath(tool, type, scope, cwd = process.cwd()) {
+  const typeConfig = getContentTypeConfig(tool, type);
+  if (!typeConfig) return void 0;
+  const root = getToolRoot(tool, 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 getToolPath(tool, scope, cwd = process.cwd()) {
+  return getContentPath(tool, "skill", scope, cwd) || "";
+}
 
 // src/utils/fs.ts
 import {
@@ -222,6 +304,26 @@ async function writeTextFile(path, content) {
   await ensureDir(dirname2(path));
   await writeFile(path, content, "utf-8");
 }
+function getAgentsPath(contentType, slug, cwd) {
+  return join3(cwd, ".agents", contentType + "s", slug);
+}
+async function copyDirectory(source, destination) {
+  const { cp } = await import("fs/promises");
+  await cp(source, destination, { recursive: true });
+}
+async function installDirectory(source, destination, method) {
+  await ensureDir(dirname2(destination));
+  if (await exists(destination)) {
+    const { rm } = await import("fs/promises");
+    await rm(destination, { recursive: 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 detectInstalledTools(cwd = process.cwd()) {
@@ -249,7 +351,8 @@ async function detectProjectTools(cwd = process.cwd()) {
   return detected;
 }
 async function isToolInstalled(tool, scope, cwd = process.cwd()) {
-  const path = getToolPath(tool, scope, cwd);
+  const effectiveScope = scope === "local" ? "project" : scope;
+  const path = getToolPath(tool, effectiveScope, cwd);
   return exists(path);
 }
 function parseToolArg(arg) {
@@ -277,102 +380,47 @@ function parseToolsArg(agents, 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 { join as join4, relative as relative2, dirname as dirname3 } from "path";
+import { readdir as readdir2, symlink as symlink2 } from "fs/promises";
 import chalk from "chalk";
 import ora from "ora";
-async function getSkillContent(item, tool) {
-  const canonicalContent = await getItemContent(item);
-  return convertSkillToTool(canonicalContent, tool);
+async function installToCentralLocation(item, sourcePath, cwd) {
+  const centralPath = getAgentsPath("skill", item.slug, cwd);
+  if (await exists(centralPath)) {
+    const { rm } = await import("fs/promises");
+    await rm(centralPath, { recursive: true });
+  }
+  await copyDirectory(sourcePath, centralPath);
+  return centralPath;
 }
-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 createToolSymlink(centralPath, destPath) {
+  await ensureDir(dirname3(destPath));
+  if (await exists(destPath)) {
+    const { rm } = await import("fs/promises");
+    await rm(destPath, { recursive: true });
   }
+  const relPath = relative2(dirname3(destPath), centralPath);
+  await symlink2(relPath, destPath);
 }
-async function installSkillForTool(item, tool, scope, method, cwd) {
+async function installSkillForTool(item, tool, scope, method, cwd, centralPath) {
   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);
+    const destDir = getContentPath(tool, "skill", scope, cwd);
+    if (!destDir) {
+      throw new Error(`${AI_TOOLS[tool].name} does not support skills`);
+    }
+    const destPath = join4(destDir, item.slug);
+    const sourcePath = getItemSourcePath(item);
+    if (method === "symlink" && centralPath) {
+      await createToolSymlink(centralPath, destPath);
+    } else if (sourcePath) {
+      await installDirectory(sourcePath, destPath, "copy");
+    } else {
+      throw new Error("External skill installation not yet implemented");
+    }
     spinner.succeed(
       chalk.green(`Installed ${item.name} for ${AI_TOOLS[tool].name}`)
     );
@@ -387,31 +435,59 @@ async function installSkillForTool(item, tool, scope, method, cwd) {
 }
 async function installSkill(item, tools, scope, method, cwd = process.cwd()) {
   const results = [];
+  const sourcePath = getItemSourcePath(item);
+  let centralPath;
+  if (method === "symlink" && sourcePath) {
+    centralPath = await installToCentralLocation(item, sourcePath, cwd);
+  }
   for (const tool of tools) {
-    const result = await installSkillForTool(item, tool, scope, method, cwd);
+    const result = await installSkillForTool(
+      item,
+      tool,
+      scope,
+      method,
+      cwd,
+      centralPath
+    );
     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);
+  const destDir = getContentPath(tool, "skill", scope, cwd);
+  if (!destDir) return false;
+  const destPath = join4(destDir, slug);
   if (!await exists(destPath)) {
     return false;
   }
-  return removeFile(destPath);
+  const { rm } = await import("fs/promises");
+  try {
+    await rm(destPath, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
 }
 async function getInstalledSkills(tool, scope, cwd = process.cwd()) {
-  const destDir = getToolPath(tool, scope, cwd);
-  if (!await exists(destDir)) {
+  const destDir = getContentPath(tool, "skill", scope, cwd);
+  if (!destDir || !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, ""));
+  const entries = await readdir2(destDir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
 }
+var skillHandler = {
+  type: "skill",
+  async install(item, tools, scope, method, cwd) {
+    return installSkill(item, tools, scope, method, cwd);
+  },
+  async uninstall(slug, tool, scope, cwd) {
+    return uninstallSkill(slug, tool, scope, cwd);
+  },
+  async listInstalled(tool, scope, cwd) {
+    return getInstalledSkills(tool, scope, cwd);
+  }
+};
 
 export {
   loadManifest,
@@ -419,20 +495,27 @@ export {
   listItems,
   searchItems,
   getItemContent,
+  getItemSourcePath,
   exists,
   ensureDir,
+  installFile,
+  removeFile,
   writeTextFile,
+  getAgentsPath,
+  installDirectory,
   AI_TOOLS,
   ALL_TOOLS,
   getToolConfig,
+  getContentPath,
+  getSettingsPath,
+  getMcpPath,
   getToolPath,
   detectInstalledTools,
   detectProjectTools,
   isToolInstalled,
   parseToolsArg,
-  parseSkillMarkdown,
-  convertSkillToTool,
   installSkill,
   uninstallSkill,
-  getInstalledSkills
+  getInstalledSkills,
+  skillHandler
 };