opkg 0.9.2 → 0.9.3

package/packages/cli/dist/chunk-CVA64SXK.js

@@ -0,0 +1,1136 @@
+#!/usr/bin/env node
+import {
+  detectPluginWithMarketplace,
+  extractBaseVersion,
+  extractPackageFromTarball,
+  hasPluginContent,
+  isUnversionedVersion
+} from "./chunk-TFQ4JBVO.js";
+import {
+  getLocalOpenPackageDir,
+  getLocalPackageYmlPath,
+  getLocalPackagesDir,
+  isRootPackage
+} from "./chunk-BCYZDID6.js";
+import {
+  loadPackageConfig
+} from "./chunk-V5OW4YEB.js";
+import {
+  extractGitHubInfo,
+  generateGitHubPackageName
+} from "./chunk-Q2N6OZJC.js";
+import {
+  resolveOutput
+} from "./chunk-BROJ6OUT.js";
+import {
+  getLatestPackageVersion,
+  getPackagePath,
+  getPackageVersionPath,
+  listPackageVersions
+} from "./chunk-XEPVYZO3.js";
+import {
+  parsePackageYml,
+  writePackageYml
+} from "./chunk-QTQYI4L5.js";
+import {
+  arePackageNamesEquivalent,
+  normalizePackageName,
+  normalizePackageNameForLookup,
+  validatePackageName
+} from "./chunk-VN22A7NW.js";
+import {
+  isPlatformId
+} from "./chunk-GKEHDSL4.js";
+import {
+  CLAUDE_PLUGIN_PATHS,
+  DEPENDENCY_ARRAYS,
+  DIR_PATTERNS,
+  FILE_PATTERNS,
+  PACKAGE_PATHS,
+  UNVERSIONED
+} from "./chunk-J4IFFBLP.js";
+import {
+  ensureDir,
+  exists,
+  readTextFile,
+  remove,
+  walkFiles,
+  writeTextFile
+} from "./chunk-S47F4OG4.js";
+import {
+  InvalidPackageError,
+  PackageNotFoundError,
+  ValidationError
+} from "./chunk-ID4SVDQZ.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/core/package-management.ts
+import { basename as basename3, relative as relative4 } from "path";
+import semver2 from "semver";
+
+// ../core/src/utils/version-ranges.ts
+import * as semver from "semver";
+function parseVersionRange(version) {
+  if (!version || version.trim() === "")
+    throw new Error("Version cannot be empty");
+  let trimmed = version.trim();
+  if (trimmed === "*" || trimmed === "latest")
+    return {
+      type: "wildcard",
+      baseVersion: "0.0.0",
+      range: "*",
+      original: trimmed
+    };
+  if (trimmed.startsWith("^")) {
+    let baseVersion = trimmed.substring(1);
+    if (!semver.valid(baseVersion))
+      throw new Error(`Invalid base version for caret range: ${baseVersion}`);
+    return {
+      type: "caret",
+      baseVersion,
+      range: trimmed,
+      original: trimmed
+    };
+  }
+  if (trimmed.startsWith("~")) {
+    let baseVersion = trimmed.substring(1);
+    if (!semver.valid(baseVersion))
+      throw new Error(`Invalid base version for tilde range: ${baseVersion}`);
+    return {
+      type: "tilde",
+      baseVersion,
+      range: trimmed,
+      original: trimmed
+    };
+  }
+  if (trimmed.match(/^[><=!]+/)) {
+    if (!semver.validRange(trimmed))
+      throw new Error(`Invalid comparison range: ${trimmed}`);
+    return {
+      type: "comparison",
+      baseVersion: semver.minVersion(trimmed)?.version || "0.0.0",
+      range: trimmed,
+      original: trimmed
+    };
+  }
+  if (semver.valid(trimmed))
+    return {
+      type: "exact",
+      baseVersion: trimmed,
+      range: trimmed,
+      original: trimmed
+    };
+  throw new Error(`Invalid version format: ${trimmed}`);
+}
+function findBestVersion(availableVersions, range) {
+  try {
+    let sortedVersions = availableVersions.filter((v) => semver.valid(v)).sort((a, b) => semver.compare(b, a));
+    return semver.maxSatisfying(sortedVersions, range, { includePrerelease: !0 });
+  } catch {
+    return null;
+  }
+}
+function getLatestVersion(availableVersions) {
+  let validVersions = availableVersions.filter((v) => semver.valid(v));
+  return validVersions.length === 0 ? null : validVersions.sort((a, b) => semver.compare(b, a))[0];
+}
+function createCaretRange(version) {
+  if (!semver.valid(version))
+    throw new Error(`Invalid version for caret range: ${version}`);
+  return `^${version}`;
+}
+function isExactVersion(version) {
+  try {
+    return parseVersionRange(version).type === "exact";
+  } catch {
+    return !1;
+  }
+}
+function resolveVersionRange(version, availableVersions) {
+  try {
+    let parsed = parseVersionRange(version);
+    switch (parsed.type) {
+      case "exact":
+        return availableVersions.includes(parsed.baseVersion) ? parsed.baseVersion : null;
+      case "wildcard":
+        return getLatestVersion(availableVersions);
+      default:
+        return findBestVersion(availableVersions, parsed.range);
+    }
+  } catch {
+    return null;
+  }
+}
+function isPrereleaseVersion(version) {
+  let parsed = semver.parse(version);
+  return !!(parsed && parsed.prerelease.length > 0);
+}
+function hasExplicitPrereleaseIntent(range) {
+  let trimmed = range.trim();
+  if (!trimmed || trimmed === "*" || trimmed.toLowerCase() === "latest" || !trimmed.includes("-"))
+    return !1;
+  try {
+    let parsedRange = new semver.Range(trimmed, { includePrerelease: !0 });
+    for (let comparatorSet of parsedRange.set)
+      for (let comparator of comparatorSet)
+        if (comparator.semver.prerelease.length > 0)
+          return !0;
+  } catch {
+    return !1;
+  }
+  return !1;
+}
+function selectVersionWithWipPolicy(availableVersions, range, options) {
+  let parsedRange = parseVersionRange(range), deduped = dedupeValidVersions(availableVersions), availableStable = sortVersionsDesc(deduped.filter((version) => !isPrereleaseVersion(version))), availablePrerelease = sortVersionsDesc(deduped.filter((version) => isPrereleaseVersion(version))), satisfyingStable = [], satisfyingPrerelease = [], result = {
+    version: null,
+    isPrerelease: !1,
+    satisfyingStable,
+    satisfyingPrerelease,
+    availableStable,
+    availablePrerelease,
+    reason: "none"
+  }, finish = () => result;
+  if (parsedRange.type === "exact") {
+    result.reason = "exact";
+    let exactMatch = deduped.find((version) => semver.eq(version, parsedRange.baseVersion));
+    return exactMatch && (isPrereleaseVersion(exactMatch) ? (satisfyingPrerelease.push(exactMatch), result.isPrerelease = !0) : satisfyingStable.push(exactMatch), result.version = exactMatch), finish();
+  }
+  let normalizedRange = parsedRange.type === "wildcard" ? "*" : parsedRange.range;
+  satisfyingStable.push(
+    ...filterSatisfying(availableStable, normalizedRange, !1)
+  ), satisfyingPrerelease.push(
+    ...filterSatisfying(availablePrerelease, normalizedRange, !0)
+  );
+  let allSatisfying = sortVersionsDesc([
+    ...satisfyingStable,
+    ...satisfyingPrerelease
+  ]);
+  if (parsedRange.type === "wildcard" ? result.reason = "wildcard" : result.reason = "range", allSatisfying.length === 0)
+    return finish();
+  let selected = allSatisfying[0];
+  return result.version = selected, result.isPrerelease = isPrereleaseVersion(selected), finish();
+}
+function dedupeValidVersions(versions) {
+  let seen = /* @__PURE__ */ new Set();
+  for (let version of versions)
+    !version || !semver.valid(version) || seen.has(version) || seen.add(version);
+  return Array.from(seen);
+}
+function sortVersionsDesc(versions) {
+  return versions.slice().sort(semver.rcompare);
+}
+function filterSatisfying(versions, range, includePrerelease) {
+  try {
+    return sortVersionsDesc(
+      versions.filter((version) => semver.satisfies(version, range, { includePrerelease }))
+    );
+  } catch {
+    return [];
+  }
+}
+
+// ../core/src/core/package.ts
+import { join as join3, relative as relative3, dirname, basename as basename2 } from "path";
+import { isJunk as isJunk3 } from "junk";
+
+// ../core/src/core/install/plugin-transformer.ts
+import { relative } from "path";
+import { isJunk } from "junk";
+
+// ../core/src/core/conversion-context/creation.ts
+function createContextFromFormat(format) {
+  let now = /* @__PURE__ */ new Date(), originalFormat = {
+    type: format.type,
+    platform: format.platform,
+    detectedAt: now,
+    confidence: format.confidence
+  }, currentFormat = {
+    type: format.type,
+    platform: format.platform
+  };
+  return logger.debug("Created conversion context from format", {
+    type: format.type,
+    platform: format.platform,
+    confidence: format.confidence
+  }), {
+    originalFormat,
+    currentFormat,
+    conversionHistory: [],
+    targetPlatform: void 0
+  };
+}
+function createContextFromPackage(pkg) {
+  let format = pkg._format || detectPackageFormat(pkg.files);
+  return logger.debug("Creating context from package", {
+    name: pkg.metadata.name,
+    hasFormat: !!pkg._format,
+    detectedType: format.type,
+    detectedPlatform: format.platform
+  }), createContextFromFormat(format);
+}
+function createPlatformContext(platform, confidence = 1) {
+  let originalFormat = {
+    type: "platform-specific",
+    platform,
+    detectedAt: /* @__PURE__ */ new Date(),
+    confidence
+  }, currentFormat = {
+    type: "platform-specific",
+    platform
+  };
+  return logger.debug("Created platform-specific context", { platform, confidence }), {
+    originalFormat,
+    currentFormat,
+    conversionHistory: [],
+    targetPlatform: void 0
+  };
+}
+function withTargetPlatform(context, targetPlatform) {
+  return {
+    ...context,
+    targetPlatform
+  };
+}
+function updateContextAfterConversion(context, newFormat, targetPlatform) {
+  let timestamp = /* @__PURE__ */ new Date(), newHistory = [
+    ...context.conversionHistory,
+    {
+      from: context.currentFormat,
+      to: newFormat,
+      targetPlatform,
+      timestamp
+    }
+  ];
+  return logger.debug("Updated context after conversion", {
+    from: {
+      type: context.currentFormat.type,
+      platform: context.currentFormat.platform
+    },
+    to: {
+      type: newFormat.type,
+      platform: newFormat.platform
+    },
+    targetPlatform,
+    totalConversions: newHistory.length
+  }), {
+    ...context,
+    currentFormat: newFormat,
+    conversionHistory: newHistory,
+    targetPlatform
+  };
+}
+
+// ../core/src/core/conversion-context/serialization.ts
+function serializeContext(context, options) {
+  let includeHistory = options?.includeHistory ?? !0;
+  return {
+    originalFormat: {
+      type: context.originalFormat.type,
+      platform: context.originalFormat.platform,
+      detectedAt: context.originalFormat.detectedAt.toISOString(),
+      confidence: context.originalFormat.confidence
+    },
+    currentFormat: {
+      type: context.currentFormat.type,
+      platform: context.currentFormat.platform
+    },
+    conversionHistory: includeHistory ? context.conversionHistory.map((record) => ({
+      from: {
+        type: record.from.type,
+        platform: record.from.platform
+      },
+      to: {
+        type: record.to.type,
+        platform: record.to.platform
+      },
+      targetPlatform: record.targetPlatform,
+      timestamp: record.timestamp.toISOString()
+    })) : [],
+    targetPlatform: context.targetPlatform
+  };
+}
+function contextToJSON(context, options) {
+  let serialized = serializeContext(context, options), pretty = options?.pretty ?? !0;
+  return JSON.stringify(serialized, null, pretty ? 2 : 0);
+}
+
+// ../core/src/core/install/format-detector.ts
+var UNIVERSAL_SUBDIRS = [
+  "commands",
+  "agents",
+  "rules",
+  "skills",
+  "hooks"
+], PLATFORM_ROOT_DIRS = {
+  ".claude": "claude",
+  ".claude-plugin": "claude-plugin",
+  ".cursor": "cursor",
+  ".opencode": "opencode",
+  ".codex": "codex",
+  ".factory": "factory",
+  ".kilocode": "kilo",
+  ".kiro": "kiro",
+  ".qwen": "qwen",
+  ".roo": "roo",
+  ".warp": "warp",
+  ".windsurf": "windsurf",
+  ".augment": "augment",
+  ".agent": "antigravity"
+};
+function detectPackageFormat(files) {
+  if (files.some(
+    (f) => f.path === ".claude-plugin/plugin.json"
+  ))
+    return {
+      type: "platform-specific",
+      platform: "claude-plugin",
+      confidence: 1,
+      analysis: {
+        universalFiles: 0,
+        platformSpecificFiles: files.length,
+        detectedPlatforms: /* @__PURE__ */ new Map([["claude-plugin", files.length]]),
+        totalFiles: files.length,
+        samplePaths: {
+          universal: [],
+          platformSpecific: [".claude-plugin/plugin.json"]
+        }
+      }
+    };
+  let analysis = {
+    universalFiles: 0,
+    platformSpecificFiles: 0,
+    detectedPlatforms: /* @__PURE__ */ new Map(),
+    totalFiles: files.length,
+    samplePaths: {
+      universal: [],
+      platformSpecific: []
+    }
+  };
+  for (let file of files) {
+    let classification = classifyFile(file.path);
+    if (classification.type === "universal")
+      analysis.universalFiles++, analysis.samplePaths.universal.length < 5 && analysis.samplePaths.universal.push(file.path);
+    else if (classification.type === "platform-specific" && classification.platform) {
+      analysis.platformSpecificFiles++;
+      let count = analysis.detectedPlatforms.get(classification.platform) || 0;
+      analysis.detectedPlatforms.set(classification.platform, count + 1), analysis.samplePaths.platformSpecific.length < 5 && analysis.samplePaths.platformSpecific.push(file.path);
+    }
+  }
+  return determineFormat(analysis);
+}
+function classifyFile(path) {
+  let firstPart = path.split("/")[0];
+  if (firstPart in PLATFORM_ROOT_DIRS)
+    return {
+      type: "platform-specific",
+      platform: PLATFORM_ROOT_DIRS[firstPart]
+    };
+  let platformSuffix = extractPlatformSuffixFromPath(path);
+  return platformSuffix ? {
+    type: "platform-specific",
+    platform: platformSuffix
+  } : UNIVERSAL_SUBDIRS.includes(firstPart) ? { type: "universal" } : { type: "other" };
+}
+function extractPlatformSuffixFromPath(path) {
+  let parts = path.split("/"), nameParts = parts[parts.length - 1].split(".");
+  if (nameParts.length >= 3) {
+    let possiblePlatform = nameParts[nameParts.length - 2];
+    if (isPlatformId(possiblePlatform))
+      return possiblePlatform;
+  }
+  return null;
+}
+function determineFormat(analysis) {
+  let { universalFiles, platformSpecificFiles, detectedPlatforms, totalFiles } = analysis;
+  if (totalFiles === 0)
+    return {
+      type: "universal",
+      confidence: 0,
+      analysis
+    };
+  let universalRatio = universalFiles / totalFiles, platformRatio = platformSpecificFiles / totalFiles;
+  if (universalRatio > 0.7)
+    return {
+      type: "universal",
+      confidence: universalRatio,
+      analysis
+    };
+  if (platformRatio > 0.7) {
+    let dominantPlatform, maxCount = 0;
+    for (let [platform, count] of detectedPlatforms)
+      count > maxCount && (maxCount = count, dominantPlatform = platform);
+    if (dominantPlatform)
+      return {
+        type: "platform-specific",
+        platform: dominantPlatform,
+        confidence: platformRatio,
+        analysis
+      };
+  }
+  return {
+    type: "universal",
+    confidence: Math.max(universalRatio, 0.3),
+    analysis
+  };
+}
+function isPlatformSpecific(format) {
+  return format.type === "platform-specific" && format.platform !== void 0;
+}
+function needsConversion(format, targetPlatform) {
+  return format.type === "universal" ? !1 : format.type === "platform-specific" && format.platform ? format.platform !== targetPlatform : !1;
+}
+function detectPackageFormatWithContext(files) {
+  let format = detectPackageFormat(files), context = createContextFromFormat(format);
+  return { format, context };
+}
+async function detectEnhancedPackageFormat(files, targetDir) {
+  let { detectPlatformMarkers, getPrimaryPlatformFromMarkers, isPurePlatformSpecific } = await import("./package-marker-detector-JELOHCL7.js"), { detectFileFormats } = await import("./file-format-detector-DEAVQPAT.js"), {
+    analyzeFormatDistribution,
+    calculatePackageConfidence,
+    determinePackageFormat: determineFromDistribution,
+    groupFilesByPlatform
+  } = await import("./format-distribution-analyzer-MIFCFIAJ.js"), markers = detectPlatformMarkers(files, targetDir);
+  if (isPurePlatformSpecific(markers)) {
+    let primaryPlatform = getPrimaryPlatformFromMarkers(markers);
+    return {
+      packageFormat: primaryPlatform,
+      detectionMethod: "package-marker",
+      confidence: 1,
+      // For marker fast-path, we still need format groups so conversion can run.
+      // Group everything under the detected platform; individual files can be no-ops
+      // if no import flow matches (e.g. plugin manifests).
+      formatGroups: /* @__PURE__ */ new Map([[primaryPlatform, files.map((f) => f.path)]]),
+      markers: {
+        matchedPatterns: markers.matches.map((m) => ({
+          platformId: m.platformId,
+          pattern: m.matchedPattern
+        })),
+        hasOpenPackageYml: markers.hasOpenPackageYml,
+        hasPackageYml: markers.hasPackageYml
+      },
+      analysis: {
+        totalFiles: files.length,
+        analyzedFiles: 0,
+        // Fast path - didn't analyze files
+        skippedFiles: files.length,
+        formatDistribution: /* @__PURE__ */ new Map([[primaryPlatform, files.length]])
+      }
+    };
+  }
+  if ((markers.hasOpenPackageYml || markers.hasPackageYml) && markers.matches.length === 0)
+    return {
+      packageFormat: "universal",
+      detectionMethod: "package-marker",
+      confidence: 1,
+      formatGroups: /* @__PURE__ */ new Map([["universal", files.map((f) => f.path)]]),
+      markers: {
+        matchedPatterns: [],
+        hasOpenPackageYml: markers.hasOpenPackageYml,
+        hasPackageYml: markers.hasPackageYml
+      },
+      analysis: {
+        totalFiles: files.length,
+        analyzedFiles: 0,
+        skippedFiles: files.length,
+        formatDistribution: /* @__PURE__ */ new Map([["universal", files.length]])
+      }
+    };
+  let fileFormats = detectFileFormats(files, targetDir), distribution = analyzeFormatDistribution(fileFormats), confidence = calculatePackageConfidence(distribution, fileFormats), packageFormat = determineFromDistribution(distribution), formatGroups = groupFilesByPlatform(fileFormats), analyzedFiles = fileFormats.size, skippedFiles = files.length - analyzedFiles;
+  return {
+    packageFormat,
+    detectionMethod: "per-file",
+    confidence,
+    fileFormats,
+    formatGroups,
+    markers: markers.matches.length > 0 ? {
+      matchedPatterns: markers.matches.map((m) => ({
+        platformId: m.platformId,
+        pattern: m.matchedPattern
+      })),
+      hasOpenPackageYml: markers.hasOpenPackageYml,
+      hasPackageYml: markers.hasPackageYml
+    } : void 0,
+    analysis: {
+      totalFiles: files.length,
+      analyzedFiles,
+      skippedFiles,
+      formatDistribution: distribution.counts
+    }
+  };
+}
+
+// ../core/src/core/install/plugin-metadata-resolver.ts
+import { join } from "path";
+async function resolvePluginMetadata(pluginDir, marketplaceEntry) {
+  let manifestPath = join(pluginDir, CLAUDE_PLUGIN_PATHS.PLUGIN_MANIFEST), hasPluginJson = await exists(manifestPath), isStrictFalse = marketplaceEntry?.strict === !1;
+  if (hasPluginJson) {
+    let pluginManifest;
+    try {
+      let content = await readTextFile(manifestPath);
+      pluginManifest = JSON.parse(content);
+    } catch (error) {
+      throw new ValidationError(
+        `Failed to parse plugin manifest at ${manifestPath}: ${error}`
+      );
+    }
+    return isStrictFalse ? (logger.warn(
+      `Plugin at '${pluginDir}' has strict:false in marketplace but contains plugin.json. Using plugin.json as primary source. Consider removing plugin.json or setting strict:true.`
+    ), {
+      manifest: pluginManifest,
+      source: "plugin.json"
+    }) : marketplaceEntry ? {
+      manifest: mergePluginMetadata(pluginManifest, marketplaceEntry),
+      source: "merged"
+    } : {
+      manifest: pluginManifest,
+      source: "plugin.json"
+    };
+  }
+  if (isStrictFalse && marketplaceEntry)
+    return {
+      manifest: marketplaceEntryToManifest(marketplaceEntry),
+      source: "marketplace"
+    };
+  throw marketplaceEntry ? new ValidationError(
+    `Plugin '${marketplaceEntry.name}' at '${pluginDir}' is missing plugin.json. Either add .claude-plugin/plugin.json or set "strict": false in marketplace entry.`
+  ) : new ValidationError(
+    `Plugin at '${pluginDir}' is missing plugin.json at ${CLAUDE_PLUGIN_PATHS.PLUGIN_MANIFEST}`
+  );
+}
+function mergePluginMetadata(pluginManifest, marketplaceEntry) {
+  return {
+    name: pluginManifest.name,
+    // Always use plugin.json name
+    version: pluginManifest.version ?? marketplaceEntry.version,
+    description: pluginManifest.description ?? marketplaceEntry.description,
+    author: pluginManifest.author ?? marketplaceEntry.author,
+    homepage: pluginManifest.homepage ?? marketplaceEntry.homepage,
+    repository: pluginManifest.repository ?? marketplaceEntry.repository,
+    license: pluginManifest.license ?? marketplaceEntry.license,
+    keywords: pluginManifest.keywords ?? marketplaceEntry.keywords,
+    commands: pluginManifest.commands ?? marketplaceEntry.commands,
+    agents: pluginManifest.agents ?? marketplaceEntry.agents,
+    hooks: pluginManifest.hooks ?? marketplaceEntry.hooks,
+    mcpServers: pluginManifest.mcpServers ?? marketplaceEntry.mcpServers,
+    lspServers: pluginManifest.lspServers ?? marketplaceEntry.lspServers
+  };
+}
+function marketplaceEntryToManifest(entry) {
+  return {
+    name: entry.name,
+    version: entry.version,
+    description: entry.description,
+    author: entry.author,
+    homepage: entry.homepage,
+    repository: entry.repository,
+    license: entry.license,
+    keywords: entry.keywords,
+    commands: entry.commands,
+    agents: entry.agents,
+    hooks: entry.hooks,
+    mcpServers: entry.mcpServers,
+    lspServers: entry.lspServers
+  };
+}
+
+// ../core/src/core/install/plugin-transformer.ts
+var transformedPluginCache = /* @__PURE__ */ new Map();
+function cacheTransformedPlugin(pkg, context) {
+  let key = `${pkg.metadata.name}@${pkg.metadata.version}`, cached = context ? { package: pkg, context } : { package: pkg, context: createPlatformContext("claude-plugin", 1) };
+  transformedPluginCache.set(key, cached);
+}
+function getTransformedPlugin(name, version) {
+  let key = `${name}@${version}`;
+  return transformedPluginCache.get(key);
+}
+async function transformPluginToPackage(pluginDir, context) {
+  let pluginManifest = (await resolvePluginMetadata(pluginDir, context?.marketplaceEntry)).manifest, metadata = {
+    name: generateGitHubPackageName({
+      gitUrl: context?.gitUrl,
+      path: context?.path,
+      resourcePath: context?.resourcePath,
+      packageName: pluginManifest.name,
+      repoPath: context?.repoPath
+    }),
+    // Claude Code plugins often omit version; normalize to a concrete value so:
+    // - logs/install output are consistent
+    // - transformed plugin cache keys remain stable
+    version: pluginManifest.version?.trim() || "0.0.0",
+    description: pluginManifest.description,
+    keywords: pluginManifest.keywords,
+    license: pluginManifest.license,
+    homepage: pluginManifest.homepage
+  };
+  pluginManifest.author?.name && (metadata.author = pluginManifest.author.name), pluginManifest.repository && (typeof pluginManifest.repository == "string" ? metadata.repository = {
+    type: "git",
+    url: pluginManifest.repository
+  } : pluginManifest.repository.url && (metadata.repository = {
+    type: pluginManifest.repository.type || "git",
+    url: pluginManifest.repository.url
+  }));
+  let files = await extractPluginFiles(pluginDir), format = detectPackageFormat(files), pkg = {
+    metadata,
+    files,
+    // Store format metadata for installation pipeline
+    _format: format
+  }, conversionContext = createPlatformContext("claude-plugin", format.confidence);
+  return cacheTransformedPlugin(pkg, conversionContext), logger.info("Transformed Claude Code plugin", {
+    name: metadata.name,
+    version: metadata.version,
+    fileCount: files.length,
+    format: format.type,
+    platform: format.platform,
+    confidence: format.confidence
+  }), { package: pkg, context: conversionContext };
+}
+async function extractPluginFiles(pluginDir) {
+  let files = [];
+  try {
+    for await (let fullPath of walkFiles(pluginDir)) {
+      let relativePath = relative(pluginDir, fullPath);
+      if (relativePath.split("/").some((part) => isJunk(part)) || relativePath.startsWith(".git/") || relativePath === ".git" || relativePath.startsWith(`${DIR_PATTERNS.CLAUDE_PLUGIN}/`))
+        continue;
+      let content = await readTextFile(fullPath);
+      files.push({
+        path: relativePath,
+        content,
+        encoding: "utf8"
+      });
+    }
+    return files;
+  } catch (error) {
+    throw new ValidationError(
+      `Failed to extract files from plugin directory ${pluginDir}: ${error}`
+    );
+  }
+}
+
+// ../core/src/core/install/path-package-loader.ts
+import { relative as relative2, basename } from "path";
+import { readFile } from "fs/promises";
+import { isJunk as isJunk2 } from "junk";
+import * as yaml from "js-yaml";
+function inferSourceType(path) {
+  return path.endsWith(FILE_PATTERNS.TGZ_FILES) || path.endsWith(FILE_PATTERNS.TAR_GZ_FILES) ? "tarball" : "directory";
+}
+async function loadPackageFromDirectory(dirPath, context) {
+  let pluginDetection = await detectPluginWithMarketplace(dirPath, context?.marketplaceEntry);
+  if (pluginDetection.isPlugin && (pluginDetection.type === "individual" || pluginDetection.type === "marketplace-defined")) {
+    logger.info(`Detected Claude Code plugin (${pluginDetection.type}), transforming to OpenPackage format`, { dirPath });
+    let { package: pkg } = await transformPluginToPackage(dirPath, context);
+    return pkg;
+  }
+  if (pluginDetection.isPlugin && pluginDetection.type === "marketplace")
+    throw new ValidationError(
+      `Directory '${dirPath}' is a Claude Code plugin marketplace. Marketplace installation requires plugin selection and should be handled by the install command.`
+    );
+  let config = await loadPackageConfig(dirPath);
+  if (!config) {
+    if (await hasPluginContent(dirPath)) {
+      let syntheticEntry = {
+        strict: !1,
+        name: context?.packageName ?? basename(dirPath),
+        source: "."
+        // minimal spec for marketplace-defined plugin without marketplace manifest
+      }, marketplaceDefined = await detectPluginWithMarketplace(dirPath, syntheticEntry);
+      if (marketplaceDefined.isPlugin && marketplaceDefined.type === "marketplace-defined") {
+        let { package: pkg } = await transformPluginToPackage(dirPath, {
+          ...context,
+          marketplaceEntry: syntheticEntry
+        });
+        return pkg;
+      }
+    }
+    if (!context?.resourcePath)
+      throw new ValidationError(
+        `Directory '${dirPath}' is not a valid OpenPackage directory or Claude Code plugin. Missing ${FILE_PATTERNS.OPENPACKAGE_YML} or ${CLAUDE_PLUGIN_PATHS.PLUGIN_MANIFEST}`
+      );
+    let fallbackBaseName = basename(dirPath);
+    config = {
+      name: context?.gitUrl ? generateGitHubPackageName({
+        gitUrl: context.gitUrl,
+        path: context.path,
+        resourcePath: context.resourcePath,
+        packageName: fallbackBaseName,
+        repoPath: context.repoPath
+      }) : fallbackBaseName,
+      version: "0.0.0"
+    };
+  }
+  if (context?.gitUrl) {
+    let originalName = config.name, scopedName = generateGitHubPackageName({
+      gitUrl: context.gitUrl,
+      path: context.path,
+      resourcePath: context.resourcePath,
+      packageName: originalName,
+      // Pass original name for non-GitHub sources
+      repoPath: context.repoPath
+    });
+    scopedName !== originalName && (config.name = scopedName);
+  }
+  let files = [];
+  try {
+    for await (let fullPath of walkFiles(dirPath)) {
+      let relativePath = relative2(dirPath, fullPath);
+      if (isJunk2(basename(relativePath)))
+        continue;
+      let content = await readTextFile(fullPath);
+      files.push({
+        path: relativePath,
+        content,
+        encoding: "utf8"
+      });
+    }
+    return {
+      metadata: config,
+      files
+    };
+  } catch (error) {
+    throw logger.error(`Failed to load package from directory: ${dirPath}`, { error }), new ValidationError(`Failed to load package from directory: ${error}`);
+  }
+}
+async function loadPackageFromTarball(tarballPath) {
+  let tarballBuffer;
+  try {
+    tarballBuffer = await readFile(tarballPath);
+  } catch (error) {
+    throw new ValidationError(`Failed to read tarball file '${tarballPath}': ${error}`);
+  }
+  let extracted = await extractPackageFromTarball(tarballBuffer), packageYmlFile = extracted.files.find(
+    (f) => f.path === PACKAGE_PATHS.MANIFEST_RELATIVE || f.path === "openpackage.yml"
+  );
+  if (!packageYmlFile)
+    throw new ValidationError(
+      `Tarball '${tarballPath}' does not contain a valid ${FILE_PATTERNS.OPENPACKAGE_YML} file`
+    );
+  let config = yaml.load(packageYmlFile.content);
+  if (!config.name)
+    throw new ValidationError(
+      `Tarball '${tarballPath}' contains invalid ${FILE_PATTERNS.OPENPACKAGE_YML}: missing name field`
+    );
+  return logger.debug(`Loaded package ${config.name}@${config.version} from tarball: ${tarballPath}`), {
+    metadata: config,
+    files: extracted.files
+  };
+}
+async function loadPackageFromPath(path, context) {
+  return inferSourceType(path) === "tarball" ? await loadPackageFromTarball(path) : await loadPackageFromDirectory(path, context);
+}
+
+// ../core/src/core/package.ts
+var PackageManager = class {
+  /**
+   * Load a package from the registry (latest version by default)
+   */
+  async loadPackage(packageName, version, opts) {
+    if (logger.debug(`Loading package: ${packageName}`, { version }), validatePackageName(packageName), version) {
+      let cachedPluginWithContext = getTransformedPlugin(packageName, version);
+      if (cachedPluginWithContext)
+        return logger.debug(`Using cached transformed plugin: ${packageName}@${version}`), cachedPluginWithContext.package;
+    }
+    let targetVersion = opts?.packageRootDir ? version ?? null : null;
+    if (!opts?.packageRootDir)
+      if (version === UNVERSIONED)
+        targetVersion = UNVERSIONED;
+      else if (version)
+        if (isExactVersion(version))
+          targetVersion = version;
+        else {
+          let availableVersions = await listPackageVersions(packageName);
+          if (availableVersions.length === 0)
+            throw new PackageNotFoundError(packageName);
+          if (targetVersion = resolveVersionRange(version, availableVersions), !targetVersion)
+            throw new PackageNotFoundError(
+              `No version of '${packageName}' satisfies range '${version}'. Available versions: ${availableVersions.join(", ")}`
+            );
+          logger.debug(`Resolved version range '${version}' to '${targetVersion}' for package '${packageName}'`);
+        }
+      else
+        targetVersion = await getLatestPackageVersion(packageName);
+    if (!targetVersion && !opts?.packageRootDir)
+      throw new PackageNotFoundError(packageName);
+    let packagePath = opts?.packageRootDir ? opts.packageRootDir : getPackageVersionPath(packageName, targetVersion ?? void 0);
+    if (!await exists(packagePath))
+      throw new PackageNotFoundError(packageName);
+    try {
+      return await loadPackageFromPath(packagePath, { packageName });
+    } catch (error) {
+      throw error instanceof PackageNotFoundError || error.name === "ValidationError" ? new PackageNotFoundError(packageName) : (logger.error(`Failed to load package: ${packageName}`, { error }), new InvalidPackageError(`Failed to load package: ${error}`));
+    }
+  }
+  /**
+   * Save a package to the registry (versioned)
+   */
+  async savePackage(pkg, options = {}) {
+    let { metadata, files } = pkg, packagePath = getPackageVersionPath(metadata.name, metadata.version);
+    logger.debug(`Saving package: ${metadata.name}@${metadata.version ?? UNVERSIONED}`, { packagePath });
+    try {
+      await ensureDir(packagePath);
+      for (let file of files) {
+        let fullPath = join3(packagePath, file.path);
+        await ensureDir(dirname(fullPath)), await writeTextFile(fullPath, file.content, file.encoding || "utf8");
+      }
+      options.partial ? await this.markPartialInManifest(packagePath) : await this.clearPartialInManifest(packagePath), logger.info(`Package '${metadata.name}@${metadata.version}' saved successfully`);
+    } catch (error) {
+      throw logger.error(`Failed to save package: ${metadata.name}@${metadata.version}`, { error }), new InvalidPackageError(`Failed to save package: ${error}`);
+    }
+  }
+  /**
+   * Delete a specific version of a package
+   */
+  async deletePackageVersion(packageName, version) {
+    logger.info(`Deleting package version: ${packageName}@${version}`), validatePackageName(packageName);
+    let packagePath = getPackageVersionPath(packageName, version);
+    if (!await exists(packagePath))
+      throw new PackageNotFoundError(`${packageName}@${version}`);
+    try {
+      await remove(packagePath), logger.info(`Package version '${packageName}@${version}' deleted successfully`);
+    } catch (error) {
+      throw logger.error(`Failed to delete package version: ${packageName}@${version}`, { error }), new InvalidPackageError(`Failed to delete package version: ${error}`);
+    }
+  }
+  /**
+   * Delete all versions of a package
+   */
+  async deletePackage(packageName) {
+    logger.info(`Deleting all versions of package: ${packageName}`), validatePackageName(packageName);
+    let packagePath = getPackagePath(packageName);
+    if (!await exists(packagePath))
+      throw new PackageNotFoundError(packageName);
+    try {
+      await remove(packagePath), logger.info(`All versions of package '${packageName}' deleted successfully`);
+    } catch (error) {
+      throw logger.error(`Failed to delete package: ${packageName}`, { error }), new InvalidPackageError(`Failed to delete package: ${error}`);
+    }
+  }
+  /**
+   * Check if a package exists in the registry (any version)
+   */
+  async packageExists(packageName) {
+    return validatePackageName(packageName), await getLatestPackageVersion(packageName) !== null;
+  }
+  /**
+   * Return local state for a specific package version, including partial metadata.
+   */
+  async getPackageVersionState(packageName, version) {
+    let packagePath = getPackageVersionPath(packageName, version);
+    if (!await exists(packagePath))
+      return { exists: !1, isPartial: !1, paths: [] };
+    let manifestPath = join3(packagePath, PACKAGE_PATHS.MANIFEST_RELATIVE), manifestExists = await exists(manifestPath), isPartial = !manifestExists;
+    if (manifestExists)
+      try {
+        isPartial = !!(await parsePackageYml(manifestPath)).partial;
+      } catch (error) {
+        logger.warn("Failed to read package manifest for partial state", { packageName, version, error }), isPartial = !0;
+      }
+    let paths = await this.listPackageFilePaths(packagePath);
+    return { exists: !0, isPartial, paths };
+  }
+  /**
+   * Discover all files in a package directory
+   */
+  async discoverPackageFiles(packagePath) {
+    let files = [];
+    try {
+      for await (let fullPath of walkFiles(packagePath)) {
+        let relativePath = relative3(packagePath, fullPath);
+        if (isJunk3(basename2(relativePath)))
+          continue;
+        let content = await readTextFile(fullPath);
+        files.push({
+          path: relativePath,
+          content,
+          encoding: "utf8"
+        });
+      }
+      return logger.debug(`Discovered ${files.length} files in package directory`, { packagePath }), files;
+    } catch (error) {
+      throw logger.error(`Failed to discover files in package directory: ${packagePath}`, { error }), new InvalidPackageError(`Failed to discover package files: ${error}`);
+    }
+  }
+  async markPartialInManifest(packagePath) {
+    let manifestPath = join3(packagePath, PACKAGE_PATHS.MANIFEST_RELATIVE);
+    if (!await exists(manifestPath))
+      return;
+    let manifest = await parsePackageYml(manifestPath);
+    manifest.partial = !0, await writePackageYml(manifestPath, manifest);
+  }
+  async clearPartialInManifest(packagePath) {
+    let manifestPath = join3(packagePath, PACKAGE_PATHS.MANIFEST_RELATIVE);
+    if (!await exists(manifestPath))
+      return;
+    let manifest = await parsePackageYml(manifestPath);
+    manifest.partial !== void 0 && (delete manifest.partial, await writePackageYml(manifestPath, manifest));
+  }
+  async listPackageFilePaths(packagePath) {
+    let paths = [];
+    for await (let fullPath of walkFiles(packagePath)) {
+      let relativePath = relative3(packagePath, fullPath);
+      isJunk3(basename2(relativePath)) || paths.push(relativePath);
+    }
+    return paths.sort(), paths;
+  }
+}, packageManager = new PackageManager();
+
+// ../core/src/core/package-management.ts
+async function ensureLocalOpenPackageStructure(targetDir) {
+  let openpackageDir = getLocalOpenPackageDir(targetDir), packagesDir = getLocalPackagesDir(targetDir);
+  await Promise.all([
+    ensureDir(openpackageDir),
+    ensureDir(packagesDir)
+  ]);
+}
+async function createWorkspacePackageYml(targetDir, force = !1, output) {
+  let out = output ?? resolveOutput();
+  await ensureLocalOpenPackageStructure(targetDir);
+  let packageYmlPath = getLocalPackageYmlPath(targetDir), projectName = basename3(targetDir), basicPackageYml = {
+    name: projectName,
+    dependencies: [],
+    "dev-dependencies": []
+  };
+  return await exists(packageYmlPath) ? force ? (await writePackageYml(packageYmlPath, basicPackageYml), logger.info(`Overwrote basic openpackage.yml with name: ${projectName}`), out.success(`Overwrote basic openpackage.yml in .openpackage/ with name: ${projectName}`), basicPackageYml) : null : (await writePackageYml(packageYmlPath, basicPackageYml), logger.info("Initialized workspace openpackage.yml"), out.success("Initialized workspace openpackage.yml in .openpackage/"), basicPackageYml);
+}
+async function addPackageToYml(targetDir, packageName, packageVersion, isDev = !1, originalVersion, silent = !1, path, git, ref, gitPath, base, output) {
+  let out = output ?? resolveOutput(), packageYmlPath = getLocalPackageYmlPath(targetDir);
+  if (!await exists(packageYmlPath))
+    return;
+  if (await isRootPackage(targetDir, packageName)) {
+    logger.debug(`Skipping manifest update: package '${packageName}' is the workspace package itself`);
+    return;
+  }
+  let config = await parsePackageYml(packageYmlPath);
+  config.dependencies || (config.dependencies = []), config[DEPENDENCY_ARRAYS.DEV_DEPENDENCIES] || (config[DEPENDENCY_ARRAYS.DEV_DEPENDENCIES] = []);
+  let normalizedPackageName = normalizePackageName(packageName), nameWithVersion = packageVersion ? `${packageName}@${packageVersion}` : packageName, dependenciesArray = config.dependencies, devDependenciesArray = config[DEPENDENCY_ARRAYS.DEV_DEPENDENCIES], findIndex = (arr) => arr.findIndex((dep) => arePackageNamesEquivalent(dep.name, normalizedPackageName)), currentLocation = null, existingIndex = findIndex(dependenciesArray);
+  existingIndex >= 0 ? currentLocation = DEPENDENCY_ARRAYS.DEPENDENCIES : (existingIndex = findIndex(devDependenciesArray), existingIndex >= 0 ? currentLocation = DEPENDENCY_ARRAYS.DEV_DEPENDENCIES : existingIndex = -1);
+  let existingRange = currentLocation && existingIndex >= 0 ? config[currentLocation][existingIndex]?.version : void 0, shouldOmitVersion = isUnversionedVersion(packageVersion) || isUnversionedVersion(originalVersion), versionToWrite = git || shouldOmitVersion ? void 0 : originalVersion;
+  if (!git && !shouldOmitVersion && packageVersion) {
+    let baseVersion = extractBaseVersion(packageVersion), defaultRange = createCaretRange(baseVersion);
+    if (versionToWrite = originalVersion ?? defaultRange, !originalVersion && existingRange) {
+      let hasPrereleaseIntent = hasExplicitPrereleaseIntent(existingRange), isNewVersionStable = !isPrereleaseVersion(packageVersion);
+      hasPrereleaseIntent ? isNewVersionStable ? (versionToWrite = createCaretRange(baseVersion), logger.debug(
+        `Updating range from prerelease-including '${existingRange}' to stable '${versionToWrite}' for ${packageName} (pack transition to ${packageVersion})`
+      )) : versionToWrite = existingRange : rangeIncludesVersion(existingRange, baseVersion) ? versionToWrite = existingRange : versionToWrite = defaultRange;
+    }
+  }
+  let urlField;
+  git && (urlField = ref ? `${git}#${ref}` : git);
+  let dependency = {
+    name: normalizedPackageName,
+    ...versionToWrite ? { version: versionToWrite } : {},
+    ...path && !git ? { path } : {},
+    // Only use path for local sources
+    ...urlField ? { url: urlField } : {},
+    // Use url with embedded ref
+    ...gitPath ? { path: gitPath } : {},
+    // Use path field for git subdirectory
+    ...base ? { base } : {}
+    // Phase 4: Base field for resource model
+  }, targetArray;
+  currentLocation === DEPENDENCY_ARRAYS.DEV_DEPENDENCIES && !isDev ? (targetArray = DEPENDENCY_ARRAYS.DEV_DEPENDENCIES, logger.info(`Keeping package in dev-dependencies: ${nameWithVersion}`)) : currentLocation === DEPENDENCY_ARRAYS.DEPENDENCIES && isDev ? (targetArray = DEPENDENCY_ARRAYS.DEV_DEPENDENCIES, logger.info(`Moving package from dependencies to dev-dependencies: ${nameWithVersion}`)) : targetArray = isDev ? DEPENDENCY_ARRAYS.DEV_DEPENDENCIES : DEPENDENCY_ARRAYS.DEPENDENCIES, currentLocation && currentLocation !== targetArray && existingIndex >= 0 && (config[currentLocation].splice(existingIndex, 1), existingIndex = -1, currentLocation = null);
+  let targetArrayRef = config[targetArray], existingTargetIndex = currentLocation === targetArray ? findIndex(targetArrayRef) : -1;
+  existingTargetIndex >= 0 ? targetArrayRef[existingTargetIndex].version !== dependency.version && (targetArrayRef[existingTargetIndex] = dependency, silent || (logger.info(`Updated existing package dependency: ${nameWithVersion}`), out.success(`Updated ${nameWithVersion} in main openpackage.yml`))) : (targetArrayRef.push(dependency), silent || (logger.info(`Added new package dependency: ${nameWithVersion}`), out.success(`Added ${nameWithVersion} to main openpackage.yml`))), await writePackageYml(packageYmlPath, config);
+}
+function doesDependencyMatchPackageName(dep, userInputName) {
+  let normalizedDepName = normalizePackageNameForLookup(dep.name), normalizedUserName = normalizePackageNameForLookup(userInputName);
+  if (normalizedDepName === normalizedUserName)
+    return !0;
+  let gitUrlRaw = dep.url || dep.git;
+  if (gitUrlRaw) {
+    let githubInfo = extractGitHubInfo(gitUrlRaw);
+    if (!githubInfo)
+      return !1;
+    let { username, repo } = githubInfo, actualPath = dep.path || (dep.subdirectory?.startsWith("./") ? dep.subdirectory.substring(2) : dep.subdirectory), possibleNames = [
+      `${username}/${repo}`,
+      `@${username}/${repo}`,
+      `gh@${username}/${repo}`
+    ];
+    if (actualPath) {
+      possibleNames.push(
+        `${username}/${repo}/${actualPath}`,
+        `@${username}/${repo}/${actualPath}`,
+        `gh@${username}/${repo}/${actualPath}`
+      );
+      let pathBasename = actualPath.split("/").pop();
+      pathBasename && pathBasename !== actualPath && possibleNames.push(
+        `${username}/${repo}/${pathBasename}`,
+        `@${username}/${repo}/${pathBasename}`,
+        `gh@${username}/${repo}/${pathBasename}`
+      );
+    }
+    let normalizedInput = normalizePackageName(userInputName);
+    for (let possibleName of possibleNames)
+      if (normalizePackageName(possibleName) === normalizedInput)
+        return !0;
+  }
+  return !1;
+}
+async function removeDependencyFromManifest(manifestPath, dependencyName) {
+  if (!await exists(manifestPath)) return { removed: !1 };
+  try {
+    let config = await parsePackageYml(manifestPath), sections = [DEPENDENCY_ARRAYS.DEPENDENCIES, DEPENDENCY_ARRAYS.DEV_DEPENDENCIES], removed = !1, removedFromSection, hadAnyDependencies = !1;
+    for (let section of sections) {
+      let arr = config[section];
+      if (!arr) continue;
+      arr.length > 0 && (hadAnyDependencies = !0);
+      let next = arr.filter((dep) => !doesDependencyMatchPackageName(dep, dependencyName));
+      next.length !== arr.length && (config[section] = next, removed = !0, removedFromSection = section);
+    }
+    return (removed || hadAnyDependencies) && await writePackageYml(manifestPath, config), { removed, section: removedFromSection };
+  } catch (error) {
+    return logger.warn(`Failed to update openpackage.yml when removing ${dependencyName}: ${error}`), { removed: !1 };
+  }
+}
+async function removePackageFromOpenpackageYml(targetDir, packageName) {
+  let packageYmlPath = getLocalPackageYmlPath(targetDir);
+  return (await removeDependencyFromManifest(packageYmlPath, packageName)).removed;
+}
+async function findMatchingDependencyInManifest(manifestPath, userInput) {
+  if (!await exists(manifestPath)) return null;
+  try {
+    let config = await parsePackageYml(manifestPath), sections = [DEPENDENCY_ARRAYS.DEPENDENCIES, DEPENDENCY_ARRAYS.DEV_DEPENDENCIES];
+    for (let section of sections) {
+      let arr = config[section];
+      if (!arr) continue;
+      let match = arr.find((dep) => doesDependencyMatchPackageName(dep, userInput));
+      if (match) return match.name;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function rangeIncludesVersion(range, version) {
+  if (!range || !version)
+    return !1;
+  try {
+    return semver2.satisfies(version, range, { includePrerelease: !0 });
+  } catch {
+    return !1;
+  }
+}
+
+export {
+  hasExplicitPrereleaseIntent,
+  selectVersionWithWipPolicy,
+  createContextFromFormat,
+  createContextFromPackage,
+  withTargetPlatform,
+  updateContextAfterConversion,
+  contextToJSON,
+  detectPackageFormat,
+  isPlatformSpecific,
+  needsConversion,
+  detectPackageFormatWithContext,
+  detectEnhancedPackageFormat,
+  loadPackageFromPath,
+  packageManager,
+  ensureLocalOpenPackageStructure,
+  createWorkspacePackageYml,
+  addPackageToYml,
+  removeDependencyFromManifest,
+  removePackageFromOpenpackageYml,
+  findMatchingDependencyInManifest
+};
+//# sourceMappingURL=chunk-CVA64SXK.js.map