skillhub 0.1.16 → 0.2.1

package/dist/{chunk-YXEKBJKF.js → chunk-SLCBZBS3.js}

@@ -12,18 +12,29 @@ var PLATFORM_PATHS = {
     project: ".codex/skills"
   },
   copilot: {
-    user: ".github/skills",
-    project: ".github/skills"
+    user: ".github/instructions",
+    project: ".github/instructions"
   },
   cursor: {
-    user: ".cursor/skills",
-    project: ".cursor/skills"
+    user: ".cursor/rules",
+    project: ".cursor/rules"
   },
   windsurf: {
-    user: ".windsurf/skills",
-    project: ".windsurf/skills"
+    user: ".windsurf/rules",
+    project: ".windsurf/rules"
   }
 };
+var FLAT_FILE_PLATFORMS = ["cursor", "windsurf", "copilot"];
+function isFlatFilePlatform(platform) {
+  return FLAT_FILE_PLATFORMS.includes(platform);
+}
+function getPlatformFilePath(platform, skillName, fileName, project = false) {
+  const basePath = getSkillsPath(platform, project);
+  if (isFlatFilePlatform(platform)) {
+    return path.join(basePath, fileName);
+  }
+  return path.join(basePath, skillName, fileName);
+}
 function getSkillsPath(platform, project = false) {
   const home = os.homedir();
   const cwd = process.cwd();
@@ -77,6 +88,8 @@ async function saveConfig(config) {
 }
 
 export {
+  isFlatFilePlatform,
+  getPlatformFilePath,
   getSkillsPath,
   getSkillPath,
   ensureSkillsDir,

package/dist/index.js

@@ -2,12 +2,14 @@
 import {
   ensureSkillsDir,
   getConfigPath,
+  getPlatformFilePath,
   getSkillPath,
   getSkillsPath,
+  isFlatFilePlatform,
   isSkillInstalled,
   loadConfig,
   saveConfig
-} from "./chunk-YXEKBJKF.js";
+} from "./chunk-SLCBZBS3.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -19,7 +21,7 @@ import fs from "fs-extra";
 import * as path from "path";
 import chalk from "chalk";
 import ora from "ora";
-import { parseSkillMd } from "skillhub-core";
+import { parseSkillMd, parseGenericInstructionFile, INSTRUCTION_FILE_PATTERNS as INSTRUCTION_FILE_PATTERNS2 } from "skillhub-core";
 
 // src/utils/api.ts
 import https from "https";
@@ -154,6 +156,7 @@ async function getSkillFiles(id) {
 
 // src/utils/github.ts
 import { Octokit } from "@octokit/rest";
+import { INSTRUCTION_FILE_PATTERNS } from "skillhub-core";
 import https2 from "https";
 var octokit = null;
 function getOctokit() {
@@ -191,17 +194,34 @@ async function fetchRawFile(owner, repo, path3, branch) {
     });
   });
 }
-async function fetchSkillContent(owner, repo, skillPath, branch = "main") {
+function getInstructionFilename(sourceFormat) {
+  const pattern = INSTRUCTION_FILE_PATTERNS.find((p) => p.format === sourceFormat);
+  return pattern?.filename || "SKILL.md";
+}
+async function fetchSkillContent(owner, repo, skillPath, branch = "main", sourceFormat = "skill.md") {
   const client = getOctokit();
-  const skillMdPath = skillPath ? `${skillPath}/SKILL.md` : "SKILL.md";
+  const filename = getInstructionFilename(sourceFormat);
+  const isStandalone = sourceFormat !== "skill.md";
+  const basePath = skillPath ? `${skillPath}/${filename}` : filename;
   let skillMdResponse;
-  const pathsToTry = [
-    skillMdPath,
-    // Common skill directories
-    ...skillPath && !skillPath.startsWith("skills/") ? [`skills/${skillPath}/SKILL.md`] : [],
-    ...skillPath && !skillPath.startsWith(".claude/") ? [`.claude/skills/${skillPath}/SKILL.md`] : [],
-    ...skillPath && !skillPath.startsWith(".github/") ? [`.github/skills/${skillPath}/SKILL.md`] : []
-  ];
+  let pathsToTry;
+  if (sourceFormat === "cursorrules" || sourceFormat === "windsurfrules") {
+    pathsToTry = [filename];
+  } else if (sourceFormat === "copilot-instructions") {
+    pathsToTry = [`.github/${filename}`];
+  } else if (sourceFormat === "agents.md") {
+    pathsToTry = [basePath];
+    if (skillPath) {
+      pathsToTry.push(filename);
+    }
+  } else {
+    pathsToTry = [
+      basePath,
+      ...skillPath && !skillPath.startsWith("skills/") ? [`skills/${skillPath}/SKILL.md`] : [],
+      ...skillPath && !skillPath.startsWith(".claude/") ? [`.claude/skills/${skillPath}/SKILL.md`] : [],
+      ...skillPath && !skillPath.startsWith(".github/") ? [`.github/skills/${skillPath}/SKILL.md`] : []
+    ];
+  }
   for (const pathToTry of pathsToTry) {
     try {
       skillMdResponse = await client.repos.getContent({
@@ -233,12 +253,20 @@ async function fetchSkillContent(owner, repo, skillPath, branch = "main") {
     }
   }
   if (!skillMdResponse) {
-    throw new Error(`SKILL.md not found at ${owner}/${repo} (tried ${pathsToTry.length} paths)`);
+    throw new Error(`${filename} not found at ${owner}/${repo} (tried ${pathsToTry.length} paths)`);
   }
   if (!("content" in skillMdResponse.data)) {
-    throw new Error("SKILL.md not found");
+    throw new Error(`${filename} not found`);
   }
   const skillMd = Buffer.from(skillMdResponse.data.content, "base64").toString("utf-8");
+  if (isStandalone) {
+    return {
+      skillMd,
+      scripts: [],
+      references: [],
+      assets: []
+    };
+  }
   const scripts = [];
   try {
     const scriptsPath = skillPath ? `${skillPath}/scripts` : "scripts";
@@ -311,6 +339,108 @@ async function getDefaultBranch(owner, repo) {
   return response.data.default_branch;
 }
 
+// src/utils/transform.ts
+var WINDSURF_CHAR_LIMIT = 6e3;
+var PLATFORM_FILE_CONFIGS = {
+  claude: {
+    getFileName: () => "SKILL.md",
+    keepOriginal: false,
+    transform: (raw) => ({ content: raw, warnings: [] })
+  },
+  codex: {
+    getFileName: () => "SKILL.md",
+    keepOriginal: false,
+    transform: (raw) => ({ content: raw, warnings: [] })
+  },
+  cursor: {
+    getFileName: (skillName) => `${skillName}.mdc`,
+    keepOriginal: true,
+    transform: transformForCursor
+  },
+  windsurf: {
+    getFileName: (skillName) => `${skillName}.md`,
+    keepOriginal: true,
+    transform: transformForWindsurf
+  },
+  copilot: {
+    getFileName: (skillName) => `${skillName}.instructions.md`,
+    keepOriginal: true,
+    transform: transformForCopilot
+  }
+};
+function getPlatformFileName(platform, skillName) {
+  return PLATFORM_FILE_CONFIGS[platform].getFileName(skillName);
+}
+function transformForPlatform(platform, rawSkillMd, parsed) {
+  return PLATFORM_FILE_CONFIGS[platform].transform(rawSkillMd, parsed);
+}
+function shouldKeepOriginal(platform) {
+  return PLATFORM_FILE_CONFIGS[platform].keepOriginal;
+}
+function transformForCursor(_raw, parsed) {
+  const warnings = [];
+  const mdcFields = [];
+  if (parsed.metadata.description) {
+    mdcFields.push(`description: ${parsed.metadata.description}`);
+  }
+  const filePatterns = parsed.metadata.triggers?.filePatterns;
+  if (filePatterns && filePatterns.length > 0) {
+    mdcFields.push(`globs: ${filePatterns.join(", ")}`);
+    mdcFields.push("alwaysApply: false");
+  } else {
+    mdcFields.push("alwaysApply: true");
+  }
+  const body = parsed.content.trim();
+  const mdcContent = `---
+${mdcFields.join("\n")}
+---
+${body}
+`;
+  return { content: mdcContent, warnings };
+}
+function transformForWindsurf(_raw, parsed) {
+  const warnings = [];
+  let body = parsed.content.trim();
+  if (!body.startsWith("# ")) {
+    body = `# ${parsed.metadata.name}
+
+${body}`;
+  }
+  if (body.length > WINDSURF_CHAR_LIMIT) {
+    warnings.push(
+      `Content exceeds Windsurf's ${WINDSURF_CHAR_LIMIT} character limit (${body.length} chars). Truncating.`
+    );
+    body = truncateAtSectionBoundary(body, WINDSURF_CHAR_LIMIT);
+  }
+  return { content: body + "\n", warnings };
+}
+function transformForCopilot(_raw, parsed) {
+  let body = parsed.content.trim();
+  if (!body.startsWith("# ")) {
+    body = `# ${parsed.metadata.name}
+
+${body}`;
+  }
+  return { content: body + "\n", warnings: [] };
+}
+function truncateAtSectionBoundary(content, limit) {
+  const notice = "\n\n<!-- Truncated by SkillHub: see SKILL.md for full content -->\n";
+  const maxLen = limit - notice.length;
+  if (content.length <= maxLen) return content;
+  const truncated = content.slice(0, maxLen);
+  const lastHeading = truncated.lastIndexOf("\n## ");
+  const lastH1 = truncated.lastIndexOf("\n# ");
+  const cutPoint = Math.max(lastHeading, lastH1);
+  if (cutPoint > 0) {
+    return truncated.slice(0, cutPoint) + notice;
+  }
+  const lastParagraph = truncated.lastIndexOf("\n\n");
+  if (lastParagraph > 0) {
+    return truncated.slice(0, lastParagraph) + notice;
+  }
+  return truncated + notice;
+}
+
 // src/commands/install.ts
 async function install(skillId, options) {
   const spinner = ora("Parsing skill ID...").start();
@@ -340,10 +470,12 @@ async function install(skillId, options) {
     }
     let skillName;
     let branch = "main";
+    let sourceFormat = "skill.md";
     if (skillInfo) {
       skillName = skillInfo.name;
       skillPath = skillInfo.skillPath;
       branch = skillInfo.branch || "main";
+      sourceFormat = skillInfo.sourceFormat || "skill.md";
       spinner.text = `Found skill: ${chalk.cyan(skillName)}`;
     } else {
       spinner.text = "Skill not in registry, fetching from GitHub...";
@@ -372,7 +504,10 @@ async function install(skillId, options) {
         spinner.text = "Downloading skill files...";
         const cachedFiles = await getSkillFiles(skillInfo.id);
         if (cachedFiles && cachedFiles.files.length > 0) {
-          content = convertCachedFilesToSkillContent(cachedFiles);
+          if (cachedFiles.sourceFormat) {
+            sourceFormat = cachedFiles.sourceFormat;
+          }
+          content = convertCachedFilesToSkillContent(cachedFiles, sourceFormat);
           spinner.text = cachedFiles.fromCache ? `Using cached files (${cachedFiles.files.length} files)` : `Downloaded ${cachedFiles.files.length} files via API`;
         }
       } catch {
@@ -386,7 +521,7 @@ async function install(skillId, options) {
         spinner.text = `Downloading from GitHub: ${owner}/${repo}/${skillPath || ""}...`;
       }
       try {
-        content = await fetchSkillContent(owner, repo, skillPath, branch);
+        content = await fetchSkillContent(owner, repo, skillPath, branch, sourceFormat);
         spinner.text = `Downloaded ${content.scripts.length} scripts, ${content.references.length} references`;
       } catch (error) {
         spinner.fail("Failed to download skill files");
@@ -408,7 +543,11 @@ async function install(skillId, options) {
       spinner.fail("Failed to download skill content");
       process.exit(1);
     }
-    const parsed = parseSkillMd(content.skillMd);
+    const parsed = sourceFormat === "skill.md" ? parseSkillMd(content.skillMd) : parseGenericInstructionFile(content.skillMd, sourceFormat, {
+      name: skillName,
+      description: skillInfo?.description || null,
+      owner
+    });
     if (!parsed.validation.isValid) {
       spinner.warn("Skill has validation issues:");
       for (const error of parsed.validation.errors) {
@@ -444,13 +583,34 @@ A different skill is already installed with the name "${actualName}":`));
     }
     spinner.text = "Installing skill...";
     await fs.ensureDir(installPath);
-    await fs.writeFile(path.join(installPath, "SKILL.md"), content.skillMd);
+    const platformFileName = getPlatformFileName(options.platform, actualName);
+    const { content: transformedContent, warnings: transformWarnings } = transformForPlatform(options.platform, content.skillMd, parsed);
+    for (const warning of transformWarnings) {
+      console.log(chalk.yellow(`  Warning: ${warning}`));
+    }
+    if (isFlatFilePlatform(options.platform)) {
+      const platformFilePath2 = getPlatformFilePath(
+        options.platform,
+        actualName,
+        platformFileName,
+        options.project
+      );
+      await fs.writeFile(platformFilePath2, transformedContent);
+    } else {
+      await fs.writeFile(path.join(installPath, platformFileName), transformedContent);
+    }
+    if (shouldKeepOriginal(options.platform)) {
+      await fs.writeFile(path.join(installPath, "SKILL.md"), content.skillMd);
+    }
     const canonicalId = skillInfo?.id || skillId;
+    const platformFilePath = isFlatFilePlatform(options.platform) ? getPlatformFilePath(options.platform, actualName, platformFileName, options.project) : null;
     await fs.writeJson(path.join(installPath, ".skillhub.json"), {
       skillId: canonicalId,
       installedAt: (/* @__PURE__ */ new Date()).toISOString(),
       platform: options.platform,
-      version: parsed.metadata.version || null
+      version: parsed.metadata.version || null,
+      platformFileName,
+      platformFilePath
     });
     if (content.scripts.length > 0) {
       const scriptsDir = path.join(installPath, "scripts");
@@ -511,30 +671,30 @@ function getPlatformName(platform) {
 function getPlatformSetupInstructions(platform, installPath) {
   switch (platform) {
     case "claude":
-      return chalk.dim("  Skills in ~/.claude/skills/ are automatically discovered by Claude Code.");
+      return chalk.dim("  Skills in .claude/skills/ are automatically discovered by Claude Code.");
     case "codex":
       return chalk.dim(`  Reference this skill in your AGENTS.md:
   @import ${installPath}/SKILL.md`);
     case "copilot":
-      return chalk.dim(`  Reference this skill in .github/copilot-instructions.md:
-  @import ${installPath}/SKILL.md`);
+      return chalk.dim("  Instructions in .github/instructions/ are automatically loaded by GitHub Copilot.");
     case "cursor":
-      return chalk.dim(`  Reference this skill in your .cursorrules file:
-  @import ${installPath}/SKILL.md`);
+      return chalk.dim("  Rules in .cursor/rules/ are automatically loaded by Cursor.");
     case "windsurf":
-      return chalk.dim(`  Reference this skill in your Windsurf configuration:
-  Path: ${installPath}/SKILL.md`);
+      return chalk.dim("  Rules in .windsurf/rules/ are automatically loaded by Windsurf.");
     default:
       return null;
   }
 }
-function convertCachedFilesToSkillContent(response) {
+var MAIN_FILE_NAMES = INSTRUCTION_FILE_PATTERNS2.map((p) => p.filename);
+function convertCachedFilesToSkillContent(response, sourceFormat = "skill.md") {
   let skillMd = "";
   const scripts = [];
   const references = [];
+  const expectedPattern = INSTRUCTION_FILE_PATTERNS2.find((p) => p.format === sourceFormat);
+  const expectedFilename = expectedPattern?.filename || "SKILL.md";
   for (const file of response.files) {
     if (!file.content) continue;
-    if (file.name === "SKILL.md" && (file.path === "SKILL.md" || file.path === file.name)) {
+    if (!skillMd && (file.name === expectedFilename || MAIN_FILE_NAMES.includes(file.name)) && file.path === file.name) {
       skillMd = file.content;
       continue;
     }
@@ -737,18 +897,31 @@ async function getInstalledSkills(platform, project = false) {
     }
     const skillPath = path2.join(skillsPath, entry.name);
     const skillMdPath = path2.join(skillPath, "SKILL.md");
-    if (!await fs2.pathExists(skillMdPath)) {
+    const metadataPath = path2.join(skillPath, ".skillhub.json");
+    const hasSkillMd = await fs2.pathExists(skillMdPath);
+    const hasMetadata = await fs2.pathExists(metadataPath);
+    if (!hasSkillMd && !hasMetadata) {
       continue;
     }
     try {
-      const content = await fs2.readFile(skillMdPath, "utf-8");
-      const parsed = parseSkillMd2(content);
-      skills.push({
-        name: parsed.metadata.name || entry.name,
-        description: parsed.metadata.description,
-        version: parsed.metadata.version,
-        path: skillPath
-      });
+      if (hasSkillMd) {
+        const content = await fs2.readFile(skillMdPath, "utf-8");
+        const parsed = parseSkillMd2(content);
+        skills.push({
+          name: parsed.metadata.name || entry.name,
+          description: parsed.metadata.description,
+          version: parsed.metadata.version,
+          path: skillPath
+        });
+      } else if (hasMetadata) {
+        const metadata = await fs2.readJson(metadataPath);
+        skills.push({
+          name: entry.name,
+          description: void 0,
+          version: metadata.version || void 0,
+          path: skillPath
+        });
+      }
     } catch {
       skills.push({
         name: entry.name,
@@ -849,7 +1022,8 @@ program.command("config").description("Manage CLI configuration").option("--set
 });
 program.command("uninstall <skill-name>").description("Uninstall a skill").option("-p, --platform <platform>", "Target platform").option("--project", "Uninstall from project instead of globally").action(async (skillName, options) => {
   const fs3 = await import("fs-extra");
-  const { getSkillPath: getSkillPath2, isSkillInstalled: isSkillInstalled2 } = await import("./paths-BVI5WSHE.js");
+  const pathModule = await import("path");
+  const { getSkillPath: getSkillPath2, isSkillInstalled: isSkillInstalled2 } = await import("./paths-PDIRF66F.js");
   const userConfig = await loadConfig();
   const platform = options.platform || userConfig.defaultPlatform || "claude";
   const installed = await isSkillInstalled2(platform, skillName, options.project);
@@ -858,13 +1032,23 @@ program.command("uninstall <skill-name>").description("Uninstall a skill").optio
     process.exit(1);
   }
   const skillPath = getSkillPath2(platform, skillName, options.project);
+  const metadataPath = pathModule.join(skillPath, ".skillhub.json");
+  if (await fs3.default.pathExists(metadataPath)) {
+    try {
+      const metadata = await fs3.default.readJson(metadataPath);
+      if (metadata.platformFilePath) {
+        await fs3.default.remove(metadata.platformFilePath);
+      }
+    } catch {
+    }
+  }
   await fs3.default.remove(skillPath);
   console.log(chalk5.green(`Skill ${skillName} uninstalled successfully.`));
 });
 program.command("update [skill-name]").description("Update installed skills").option("-p, --platform <platform>", "Target platform").option("--all", "Update all installed skills").action(async (skillName, options) => {
   const fsExtra = await import("fs-extra");
   const pathModule = await import("path");
-  const { getSkillsPath: getSkillsPath2, getSkillPath: getSkillPath2 } = await import("./paths-BVI5WSHE.js");
+  const { getSkillsPath: getSkillsPath2, getSkillPath: getSkillPath2 } = await import("./paths-PDIRF66F.js");
   const userConfig = await loadConfig();
   const platform = options.platform || userConfig.defaultPlatform || "claude";
   const ALL_PLATFORMS2 = ["claude", "codex", "copilot", "cursor", "windsurf"];

package/dist/{paths-BVI5WSHE.js → paths-PDIRF66F.js}

@@ -2,18 +2,22 @@ import {
   detectPlatform,
   ensureSkillsDir,
   getConfigPath,
+  getPlatformFilePath,
   getSkillPath,
   getSkillsPath,
+  isFlatFilePlatform,
   isSkillInstalled,
   loadConfig,
   saveConfig
-} from "./chunk-YXEKBJKF.js";
+} from "./chunk-SLCBZBS3.js";
 export {
   detectPlatform,
   ensureSkillsDir,
   getConfigPath,
+  getPlatformFilePath,
   getSkillPath,
   getSkillsPath,
+  isFlatFilePlatform,
   isSkillInstalled,
   loadConfig,
   saveConfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillhub",
-  "version": "0.1.16",
+  "version": "0.2.1",
   "description": "CLI tool for managing AI Agent skills - search, install, and update skills for Claude, Codex, Copilot, and more",
   "author": "SkillHub Contributors",
   "license": "MIT",