skill-port 0.1.3 → 0.2.0

package/dist/{chunk-OZ2PBTWL.js → chunk-ZRQAK25B.js}

@@ -1,8 +1,103 @@
-// src/core/scopes.ts
-import { accessSync } from "fs";
-import { access, readdir } from "fs/promises";
+// src/core/plugins.ts
+import { access, readdir, readFile } from "fs/promises";
 import os from "os";
 import path from "path";
+var PROVIDER_SKILL_DIRS = [
+  { subpath: "skills", provider: "claude-code" },
+  { subpath: path.join(".claude", "skills"), provider: "claude-code" },
+  { subpath: path.join(".agents", "skills"), provider: "codex" },
+  { subpath: path.join(".cursor", "skills"), provider: "cursor" }
+];
+async function readInstalledPlugins(homeDir) {
+  const home = homeDir ?? (process.env.SKILL_PORT_HOME ?? os.homedir());
+  const filePath = path.join(home, ".claude", "plugins", "installed_plugins.json");
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!parsed.plugins || typeof parsed.plugins !== "object") {
+    return [];
+  }
+  const entries = [];
+  for (const installs of Object.values(parsed.plugins)) {
+    if (!Array.isArray(installs)) {
+      continue;
+    }
+    for (const install of installs) {
+      if (install && typeof install.installPath === "string") {
+        entries.push({
+          scope: String(install.scope ?? "user"),
+          installPath: install.installPath,
+          version: String(install.version ?? "unknown")
+        });
+      }
+    }
+  }
+  return entries;
+}
+async function listPluginSkills(provider, homeDir) {
+  const installs = await readInstalledPlugins(homeDir);
+  const output = [];
+  for (const install of installs) {
+    for (const { subpath, provider: dirProvider } of PROVIDER_SKILL_DIRS) {
+      if (provider !== "all" && provider !== dirProvider) {
+        continue;
+      }
+      const skillsRoot = path.join(install.installPath, subpath);
+      const entries = await readDirSafe(skillsRoot);
+      for (const entry of entries) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        const skillDir = path.join(skillsRoot, entry.name);
+        if (!await pathExists(path.join(skillDir, "SKILL.md"))) {
+          continue;
+        }
+        output.push({
+          provider: dirProvider,
+          scope: "plugin",
+          name: entry.name,
+          path: skillDir
+        });
+      }
+    }
+  }
+  return output.sort((a, b) => {
+    if (a.provider !== b.provider) {
+      return a.provider.localeCompare(b.provider);
+    }
+    return a.name.localeCompare(b.name);
+  });
+}
+async function readDirSafe(dirPath) {
+  try {
+    return await readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+async function pathExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/scopes.ts
+import { accessSync } from "fs";
+import { access as access2, readdir as readdir2 } from "fs/promises";
+import os2 from "os";
+import path2 from "path";
 
 // src/constants.ts
 var ISSUE_CODES = {
@@ -14,6 +109,9 @@ var ISSUE_CODES = {
   OPENAI_FIELD_DROPPED: "SP202",
   NAME_DERIVED: "SP301",
   DESCRIPTION_DERIVED: "SP302",
+  PLUGIN_FILE_MISSING: "SP401",
+  PLUGIN_FILE_INVALID: "SP402",
+  PLUGIN_WRITE_BLOCKED: "SP403",
   STRICT_BLOCKED: "SP900"
 };
 var FRONTMATTER_KEY_ORDER = [
@@ -37,7 +135,7 @@ var PROVIDER_ORDER = ["codex", "claude-code", "cursor"];
 function getScopeRoots(cwd) {
   const localRoot = cwd;
   const projectRoot = findProjectRoot(cwd);
-  const userRoot = process.env.SKILL_PORT_HOME ?? os.homedir();
+  const userRoot = process.env.SKILL_PORT_HOME ?? os2.homedir();
   return {
     userRoot,
     projectRoot,
@@ -47,11 +145,11 @@ function getScopeRoots(cwd) {
 function providerSubpath(provider) {
   switch (provider) {
     case "codex":
-      return path.join(".agents", "skills");
+      return path2.join(".agents", "skills");
     case "claude-code":
-      return path.join(".claude", "skills");
+      return path2.join(".claude", "skills");
     case "cursor":
-      return path.join(".cursor", "skills");
+      return path2.join(".cursor", "skills");
     default:
       return assertNever(provider);
   }
@@ -60,19 +158,21 @@ function resolveSkillsRoot(provider, scope, cwd = process.cwd()) {
   const roots = getScopeRoots(cwd);
   switch (scope) {
     case "user":
-      return path.join(roots.userRoot, providerSubpath(provider));
+      return path2.join(roots.userRoot, providerSubpath(provider));
     case "project":
-      return path.join(roots.projectRoot, providerSubpath(provider));
+      return path2.join(roots.projectRoot, providerSubpath(provider));
     case "local":
-      return path.join(roots.localRoot, providerSubpath(provider));
+      return path2.join(roots.localRoot, providerSubpath(provider));
+    case "plugin":
+      throw new Error("Plugin skills are resolved via installed_plugins.json, not a fixed root path.");
     default:
       return assertNever(scope);
   }
 }
 function resolveSkillPath(provider, scope, skillName, cwd = process.cwd()) {
   const normalizedSkillName = validateSkillName(skillName);
-  const root = path.resolve(resolveSkillsRoot(provider, scope, cwd));
-  const resolved = path.resolve(root, normalizedSkillName);
+  const root = path2.resolve(resolveSkillsRoot(provider, scope, cwd));
+  const resolved = path2.resolve(root, normalizedSkillName);
   if (!isWithinRoot(root, resolved)) {
     throw new Error(
       `[${ISSUE_CODES.INVALID_SKILL_NAME}] Invalid skill name '${skillName}'. Skill names must resolve under the provider root.`
@@ -81,17 +181,20 @@ function resolveSkillPath(provider, scope, skillName, cwd = process.cwd()) {
   return resolved;
 }
 async function listSkills(scope, provider, cwd = process.cwd()) {
+  if (scope === "plugin") {
+    return listPluginSkills(provider);
+  }
   const providers = provider === "all" ? PROVIDER_ORDER : [provider];
   const output = [];
   for (const candidateProvider of providers) {
     const root = resolveSkillsRoot(candidateProvider, scope, cwd);
-    const entries = await readDirSafe(root);
+    const entries = await readDirSafe2(root);
     for (const entry of entries) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const skillDir = path.join(root, entry.name);
-      if (!await pathExists(path.join(skillDir, "SKILL.md"))) {
+      const skillDir = path2.join(root, entry.name);
+      if (!await pathExists2(path2.join(skillDir, "SKILL.md"))) {
         continue;
       }
       output.push({
@@ -110,9 +213,12 @@ async function listSkills(scope, provider, cwd = process.cwd()) {
   });
 }
 async function resolveSkillForConvert(skillName, scope, from, cwd = process.cwd()) {
+  if (scope === "plugin") {
+    return resolvePluginSkill(skillName, from);
+  }
   if (from !== "auto") {
     const explicitPath = resolveSkillPath(from, scope, skillName, cwd);
-    if (!await pathExists(path.join(explicitPath, "SKILL.md"))) {
+    if (!await pathExists2(path2.join(explicitPath, "SKILL.md"))) {
       throw new Error(
         `Skill '${skillName}' was not found for provider '${from}' in scope '${scope}' (${explicitPath}).`
       );
@@ -122,7 +228,7 @@ async function resolveSkillForConvert(skillName, scope, from, cwd = process.cwd(
   const matches = [];
   for (const provider of PROVIDER_ORDER) {
     const candidatePath = resolveSkillPath(provider, scope, skillName, cwd);
-    if (await pathExists(path.join(candidatePath, "SKILL.md"))) {
+    if (await pathExists2(path2.join(candidatePath, "SKILL.md"))) {
       matches.push({ provider, path: candidatePath });
     }
   }
@@ -142,7 +248,7 @@ function resolveDefaultOutputPath(to, targetScope, skillName, cwd = process.cwd(
 }
 function validateSkillName(skillName) {
   const normalized = skillName.trim();
-  const separators = [path.sep, path.posix.sep, path.win32.sep];
+  const separators = [path2.sep, path2.posix.sep, path2.win32.sep];
   if (!normalized) {
     throw new Error(
       `[${ISSUE_CODES.INVALID_SKILL_NAME}] Invalid skill name '${skillName}'. Skill name cannot be empty.`
@@ -153,23 +259,23 @@ function validateSkillName(skillName) {
       `[${ISSUE_CODES.INVALID_SKILL_NAME}] Invalid skill name '${skillName}'. Dot path segments are not allowed.`
     );
   }
-  if (path.isAbsolute(normalized) || separators.some((sep) => sep && normalized.includes(sep))) {
+  if (path2.isAbsolute(normalized) || separators.some((sep) => sep && normalized.includes(sep))) {
     throw new Error(
       `[${ISSUE_CODES.INVALID_SKILL_NAME}] Invalid skill name '${skillName}'. Path separators are not allowed.`
     );
   }
   return normalized;
 }
-async function readDirSafe(dirPath) {
+async function readDirSafe2(dirPath) {
   try {
-    return await readdir(dirPath, { withFileTypes: true });
+    return await readdir2(dirPath, { withFileTypes: true });
   } catch {
     return [];
   }
 }
-async function pathExists(filePath) {
+async function pathExists2(filePath) {
   try {
-    await access(filePath);
+    await access2(filePath);
     return true;
   } catch {
     return false;
@@ -178,38 +284,58 @@ async function pathExists(filePath) {
 function findProjectRoot(start) {
   const override = process.env.SKILL_PORT_PROJECT_ROOT;
   if (override) {
-    return path.resolve(override);
+    return path2.resolve(override);
   }
-  let current = path.resolve(start);
+  let current = path2.resolve(start);
   while (true) {
-    const gitMarker = path.join(current, ".git");
+    const gitMarker = path2.join(current, ".git");
     try {
       accessSync(gitMarker);
       return current;
     } catch {
     }
-    const parent = path.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current) {
-      return path.resolve(start);
+      return path2.resolve(start);
     }
     current = parent;
   }
 }
+async function resolvePluginSkill(skillName, from) {
+  const normalizedName = validateSkillName(skillName);
+  const provider = from === "auto" ? "all" : from;
+  const skills = await listPluginSkills(provider);
+  const matches = skills.filter((s) => s.name === normalizedName);
+  if (matches.length === 0) {
+    throw new Error(`Skill '${skillName}' was not found in scope 'plugin'.`);
+  }
+  if (from === "auto" && matches.length > 1) {
+    const uniqueProviders = new Set(matches.map((m) => m.provider));
+    if (uniqueProviders.size > 1) {
+      const providers = Array.from(uniqueProviders).join(", ");
+      throw new Error(
+        `Skill '${skillName}' exists for multiple providers in scope 'plugin' (${providers}). Specify --from.`
+      );
+    }
+  }
+  const match = matches[0];
+  return { provider: match.provider, path: match.path };
+}
 function assertNever(value) {
   throw new Error(`Unsupported value: ${String(value)}`);
 }
 function isWithinRoot(root, candidate) {
-  const relative = path.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+  const relative = path2.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
 }
 
 // src/core/convert.ts
-import { access as access3, mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import path7 from "path";
+import { access as access4, mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import path8 from "path";
 
 // src/core/skill-file.ts
-import { readFile, writeFile } from "fs/promises";
-import path2 from "path";
+import { readFile as readFile2, writeFile } from "fs/promises";
+import path3 from "path";
 
 // src/core/frontmatter.ts
 import yaml from "js-yaml";
@@ -297,24 +423,24 @@ function orderFrontmatter(frontmatter) {
 
 // src/core/skill-file.ts
 async function readSkillDocument(skillDir) {
-  const skillPath = path2.join(skillDir, "SKILL.md");
-  const raw = await readFile(skillPath, "utf8");
+  const skillPath = path3.join(skillDir, "SKILL.md");
+  const raw = await readFile2(skillPath, "utf8");
   return parseSkillMarkdown(raw);
 }
 async function writeSkillDocument(skillDir, skill) {
-  const skillPath = path2.join(skillDir, "SKILL.md");
+  const skillPath = path3.join(skillDir, "SKILL.md");
   const serialized = serializeSkillMarkdown(skill);
   await writeFile(skillPath, serialized, "utf8");
 }
 
 // src/adapters/shared.ts
-import path3 from "path";
+import path4 from "path";
 var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function deriveNameAndDescription(skillDir, frontmatter, body) {
   const issues = [];
   let name = readString(frontmatter.name);
   if (!name) {
-    name = path3.basename(skillDir);
+    name = path4.basename(skillDir);
     issues.push({
       code: ISSUE_CODES.NAME_DERIVED,
       field: "name",
@@ -433,14 +559,14 @@ function writeCursorSkill(canonical) {
 }
 
 // src/adapters/openai.ts
-import path5 from "path";
+import path6 from "path";
 
 // src/core/files.ts
-import { cp, mkdir, readFile as readFile2, rm, stat, unlink, writeFile as writeFile2 } from "fs/promises";
-import path4 from "path";
+import { cp, mkdir, readFile as readFile3, rm, stat, unlink, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
 import yaml2 from "js-yaml";
 async function ensureOutputDirectory(outputDir, overwrite) {
-  const resolvedOutput = path4.resolve(outputDir);
+  const resolvedOutput = path5.resolve(outputDir);
   let outputExists = false;
   try {
     await stat(resolvedOutput);
@@ -470,7 +596,7 @@ async function copySkillDirectory(sourceDir, outputDir) {
 async function readYamlFile(filePath) {
   let raw;
   try {
-    raw = await readFile2(filePath, "utf8");
+    raw = await readFile3(filePath, "utf8");
   } catch (error) {
     const nodeError = error;
     if (nodeError?.code === "ENOENT") {
@@ -496,7 +622,7 @@ async function readYamlFile(filePath) {
   }
 }
 async function writeYamlFile(filePath, data) {
-  await mkdir(path4.dirname(filePath), { recursive: true });
+  await mkdir(path5.dirname(filePath), { recursive: true });
   const text = yaml2.dump(data, {
     lineWidth: -1,
     noRefs: true,
@@ -513,7 +639,7 @@ async function removeFileIfExists(filePath) {
   }
 }
 function isFilesystemRoot(targetPath) {
-  const parsed = path4.parse(targetPath);
+  const parsed = path5.parse(targetPath);
   return parsed.root === targetPath;
 }
 
@@ -529,7 +655,7 @@ async function readOpenAiSkill(skillDir) {
     }
   ];
   const { name, description, issues } = deriveNameAndDescription(skillDir, frontmatter, doc.body);
-  const openaiPath = path5.join(skillDir, "agents", "openai.yaml");
+  const openaiPath = path6.join(skillDir, "agents", "openai.yaml");
   const openaiRead = await readYamlFile(openaiPath);
   const openaiConfig = openaiRead.data;
   const warnings = [...issues];
@@ -677,11 +803,11 @@ function assertNever2(value) {
 }
 
 // src/core/detect.ts
-import { access as access2 } from "fs/promises";
-import path6 from "path";
+import { access as access3 } from "fs/promises";
+import path7 from "path";
 async function exists(filePath) {
   try {
-    await access2(filePath);
+    await access3(filePath);
     return true;
   } catch {
     return false;
@@ -689,11 +815,11 @@ async function exists(filePath) {
 }
 async function detectProvider(skillDir) {
   const issues = [];
-  const openaiConfigPath = path6.join(skillDir, "agents", "openai.yaml");
+  const openaiConfigPath = path7.join(skillDir, "agents", "openai.yaml");
   if (await exists(openaiConfigPath)) {
     return { provider: "codex", issues };
   }
-  const normalized = skillDir.split(path6.sep).join("/").toLowerCase();
+  const normalized = skillDir.split(path7.sep).join("/").toLowerCase();
   if (normalized.includes("/.claude/skills/")) {
     return { provider: "claude-code", issues };
   }
@@ -770,10 +896,10 @@ var StrictModeError = class extends Error {
   }
 };
 async function convertSkill(options) {
-  const inputDir = path7.resolve(options.input);
+  const inputDir = path8.resolve(options.input);
   const targetProvider = options.to;
-  const outputDir = path7.resolve(
-    options.out ?? path7.join(path7.dirname(inputDir), `${path7.basename(inputDir)}-${targetProvider}`)
+  const outputDir = path8.resolve(
+    options.out ?? path8.join(path8.dirname(inputDir), `${path8.basename(inputDir)}-${targetProvider}`)
   );
   await assertSkillDirectory(inputDir);
   const sourceProvider = await resolveSourceProvider(inputDir, options.from);
@@ -816,7 +942,7 @@ async function convertSkill(options) {
   }
   let wroteFiles = false;
   if (!options.dryRun) {
-    if (path7.resolve(outputDir) === path7.resolve(inputDir)) {
+    if (path8.resolve(outputDir) === path8.resolve(inputDir)) {
       if (sourceProvider === targetProvider) {
         throw new Error(
           `Detected source provider '${sourceProvider}' and target provider '${targetProvider}' for the same skill path (${outputDir}). This is a no-op conversion to the same provider. Choose a different --to provider, or set --target-scope/--out to write elsewhere.`
@@ -832,7 +958,7 @@ async function convertSkill(options) {
       frontmatter: writeResult.frontmatter,
       body: writeResult.body
     });
-    const outputOpenAiPath = path7.join(outputDir, "agents", "openai.yaml");
+    const outputOpenAiPath = path8.join(outputDir, "agents", "openai.yaml");
     if (targetProvider === "codex" && writeResult.openaiYaml) {
       await writeYamlFile(outputOpenAiPath, writeResult.openaiYaml);
     } else {
@@ -846,8 +972,8 @@ async function convertSkill(options) {
         });
       }
     }
-    const reportPath = path7.resolve(options.report ?? path7.join(outputDir, "skill-port.report.json"));
-    await mkdir2(path7.dirname(reportPath), { recursive: true });
+    const reportPath = path8.resolve(options.report ?? path8.join(outputDir, "skill-port.report.json"));
+    await mkdir2(path8.dirname(reportPath), { recursive: true });
     await writeFile3(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf8");
     wroteFiles = true;
@@ -863,8 +989,13 @@ async function convertSkill(options) {
 async function convertScopedSkill(options) {
   const scope = options.scope ?? "user";
   const targetScope = options.targetScope ?? scope;
+  if (targetScope === "plugin") {
+    throw new Error(
+      `[${ISSUE_CODES.PLUGIN_WRITE_BLOCKED}] Cannot write to plugin scope. Plugin skills are managed by the plugin system. Use --target-scope user|project|local instead.`
+    );
+  }
   const source = await resolveSkillForConvert(options.skill, scope, options.from ?? "auto");
-  const output = options.out ? path7.resolve(options.out) : resolveDefaultOutputPath(options.to, targetScope, options.skill);
+  const output = options.out ? path8.resolve(options.out) : resolveDefaultOutputPath(options.to, targetScope, options.skill);
   return convertSkill({
     input: source.path,
     to: options.to,
@@ -884,9 +1015,9 @@ async function resolveSourceProvider(inputDir, from) {
   return detection.provider;
 }
 async function assertSkillDirectory(inputDir) {
-  const skillFile = path7.join(inputDir, "SKILL.md");
+  const skillFile = path8.join(inputDir, "SKILL.md");
   try {
-    await access3(skillFile);
+    await access4(skillFile);
   } catch {
     throw new Error(`Input path is not a skill directory. Missing SKILL.md: ${skillFile}`);
   }
@@ -938,6 +1069,8 @@ function formatSkillsText(skills, scope, provider, showPaths = false) {
 }
 
 export {
+  readInstalledPlugins,
+  listPluginSkills,
   validateSkillName,
   StrictModeError,
   convertSkill,

package/dist/cli.js

@@ -6,13 +6,13 @@ import {
   formatTextReport,
   listSkillsByScope,
   validateSkillName
-} from "./chunk-OZ2PBTWL.js";
+} from "./chunk-ZRQAK25B.js";
 
 // src/cli.ts
 import path from "path";
 import process from "process";
 var PROVIDERS = ["codex", "claude-code", "cursor"];
-var SCOPES = ["user", "project", "local"];
+var SCOPES = ["user", "project", "local", "plugin"];
 function printUsage() {
   const usage = `skill-port v0.1.0
 
@@ -24,7 +24,7 @@ Providers:
   codex | claude-code | cursor
 
 Scopes:
-  user | project | local
+  user | project | local | plugin
 
 list options:
   --scope <scope>           Scope to scan (default: user)
@@ -38,7 +38,9 @@ convert options:
   --all                     Convert all skills in scope (cannot be used with <skill-name>)
                            Continues per-skill on errors; exits non-zero if any fail
   --scope <scope>           Source scope (default: user)
+                           Use 'plugin' for skills from installed Claude Code plugins
   --target-scope <scope>    Target scope (default: same as --scope)
+                           Note: 'plugin' is read-only and cannot be used here
   --out <dir>               Explicit output directory (overrides scope path)
   --report <path>           Report output path (default: <out>/skill-port.report.json)
   --strict                  Fail on lossy conversion or conflicts

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 type Provider = "codex" | "claude-code" | "cursor";
-type Scope = "user" | "project" | "local";
+type Scope = "user" | "project" | "local" | "plugin";
 interface OpenAiSkillConfig {
     interface?: Record<string, unknown>;
     policy?: {
@@ -76,6 +76,21 @@ interface ListedSkill {
     name: string;
     path: string;
 }
+/**
+ * Represents one installed plugin entry from installed_plugins.json.
+ * `scope` is typed as `string` (not `Scope`) because it represents the
+ * plugin install scope from the JSON file, which may not map 1:1 to
+ * skill-port's `Scope` type.
+ */
+interface PluginInstall {
+    readonly scope: string;
+    readonly installPath: string;
+    readonly version: string;
+}
+interface InstalledPluginsFile {
+    readonly version: number;
+    readonly plugins: Record<string, readonly PluginInstall[]>;
+}
 interface ConvertResult {
     outputDir: string;
     report: ConversionReport;
@@ -95,4 +110,7 @@ declare function formatTextReport(result: ConvertResult, strictError?: boolean):
 declare function listSkillsByScope(scope: Scope, provider: Provider | "all", cwd?: string): Promise<ListedSkill[]>;
 declare function formatSkillsText(skills: ListedSkill[], scope: Scope, provider: Provider | "all", showPaths?: boolean): string;
 
-export { type CanonicalSkill, type ConversionReport, type ConvertOptions, type ConvertResult, type ListedSkill, type Provider, type ReportIssue, type ReportMapping, type Scope, type ScopedConvertOptions, StrictModeError, convertScopedSkill, convertSkill, formatSkillsText, formatTextReport, listSkillsByScope };
+declare function readInstalledPlugins(homeDir?: string): Promise<readonly PluginInstall[]>;
+declare function listPluginSkills(provider: Provider | "all", homeDir?: string): Promise<ListedSkill[]>;
+
+export { type CanonicalSkill, type ConversionReport, type ConvertOptions, type ConvertResult, type InstalledPluginsFile, type ListedSkill, type PluginInstall, type Provider, type ReportIssue, type ReportMapping, type Scope, type ScopedConvertOptions, StrictModeError, convertScopedSkill, convertSkill, formatSkillsText, formatTextReport, listPluginSkills, listSkillsByScope, readInstalledPlugins };

package/dist/index.js

@@ -4,13 +4,17 @@ import {
   convertSkill,
   formatSkillsText,
   formatTextReport,
-  listSkillsByScope
-} from "./chunk-OZ2PBTWL.js";
+  listPluginSkills,
+  listSkillsByScope,
+  readInstalledPlugins
+} from "./chunk-ZRQAK25B.js";
 export {
   StrictModeError,
   convertScopedSkill,
   convertSkill,
   formatSkillsText,
   formatTextReport,
-  listSkillsByScope
+  listPluginSkills,
+  listSkillsByScope,
+  readInstalledPlugins
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skill-port",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Convert AI coding skills across OpenAI/Codex, Claude Code, and Cursor Skills formats.",
   "license": "MIT",
   "type": "module",