@agntn/registries 0.2.0 → 0.3.1

package/packages/omp/extensions/registries.ts

@@ -0,0 +1,112 @@
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import type { AgentToolResult, ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+
+import type * as RegistryTools from "../../../dist/tool-operations.d.mts";
+
+const sourceModulePath = fileURLToPath(new URL("../../../src/tool-operations.ts", import.meta.url));
+let toolOperationsPromise: Promise<typeof RegistryTools> | undefined;
+
+function loadToolOperations(): Promise<typeof RegistryTools> {
+  toolOperationsPromise ??= (
+    existsSync(sourceModulePath)
+      ? import("../../../src/tool-operations.ts")
+      : import("../../../dist/tool-operations.mjs")
+  ) as Promise<typeof RegistryTools>;
+  return toolOperationsPromise;
+}
+
+type RegistryToolResult = AgentToolResult<unknown>;
+
+export default function registriesExtension(pi: ExtensionAPI): void {
+  const { Type } = pi.typebox;
+  const PURL = Type.String({
+    minLength: 1,
+    maxLength: 2_048,
+    description: "Package URL, for example pkg:npm/lodash or pkg:pypi/requests@2.32.3",
+  });
+  const PURLParams = Type.Object({ purl: PURL }, { additionalProperties: false });
+  const BulkPackagesParams = Type.Object(
+    {
+      purls: Type.Array(PURL, { minItems: 1, maxItems: 50 }),
+      concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 50 })),
+    },
+    { additionalProperties: false },
+  );
+  const EmptyParams = Type.Object({}, { additionalProperties: false });
+
+  pi.setLabel("Registries");
+
+  pi.registerTool({
+    name: "registries_package",
+    label: "Registry Package",
+    description: "Fetch normalized metadata for one package URL",
+    parameters: PURLParams,
+    approval: "read",
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { packageOperation } = await loadToolOperations();
+      return packageOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_versions",
+    label: "Registry Versions",
+    description: "List normalized versions for one package URL",
+    parameters: PURLParams,
+    approval: "read",
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { versionsOperation } = await loadToolOperations();
+      return versionsOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_dependencies",
+    label: "Registry Dependencies",
+    description: "List dependencies for a versioned package URL",
+    parameters: PURLParams,
+    approval: "read",
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { dependenciesOperation } = await loadToolOperations();
+      return dependenciesOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_maintainers",
+    label: "Registry Maintainers",
+    description: "List normalized maintainers for one package URL",
+    parameters: PURLParams,
+    approval: "read",
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { maintainersOperation } = await loadToolOperations();
+      return maintainersOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_bulk_packages",
+    label: "Registry Bulk Packages",
+    description: "Fetch normalized metadata for up to 50 package URLs",
+    parameters: BulkPackagesParams,
+    approval: "read",
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { bulkPackagesOperation } = await loadToolOperations();
+      return bulkPackagesOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_ecosystems",
+    label: "Registry Ecosystems",
+    description: "List package ecosystems registered by this package",
+    parameters: EmptyParams,
+    approval: "read",
+    async execute(): Promise<RegistryToolResult> {
+      const { ecosystemsOperation } = await loadToolOperations();
+      return ecosystemsOperation();
+    },
+  });
+}

package/packages/pi/extensions/registries.ts

@@ -0,0 +1,125 @@
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import type { AgentToolResult, ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+import type * as RegistryTools from "../../../dist/tool-operations.d.mts";
+
+const sourceModuleUrl = new URL("../../../src/tool-operations.ts", import.meta.url);
+const distributionModuleUrl = new URL("../../../dist/tool-operations.mjs", import.meta.url);
+let toolOperationsPromise: Promise<typeof RegistryTools> | undefined;
+
+function loadToolOperations(): Promise<typeof RegistryTools> {
+  toolOperationsPromise ??= import(
+    existsSync(fileURLToPath(sourceModuleUrl)) ? sourceModuleUrl.href : distributionModuleUrl.href
+  ) as Promise<typeof RegistryTools>;
+  return toolOperationsPromise;
+}
+
+const PURL = Type.String({
+  minLength: 1,
+  maxLength: 2_048,
+  description: "Package URL, for example pkg:npm/lodash or pkg:pypi/requests@2.32.3",
+});
+const PURLParams = Type.Object({ purl: PURL }, { additionalProperties: false });
+const BulkPackagesParams = Type.Object(
+  {
+    purls: Type.Array(PURL, { minItems: 1, maxItems: 50 }),
+    concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 50 })),
+  },
+  { additionalProperties: false },
+);
+const EmptyParams = Type.Object({}, { additionalProperties: false });
+
+type RegistryToolResult = AgentToolResult<unknown>;
+
+export default function registriesExtension(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "registries_package",
+    label: "Registry Package",
+    description: "Fetch normalized metadata for one package URL",
+    promptSnippet: "Use registries_package to inspect normalized package metadata.",
+    promptGuidelines: [
+      "Use registries_package with a PURL such as pkg:npm/lodash or pkg:pypi/requests.",
+    ],
+    parameters: PURLParams,
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { packageOperation } = await loadToolOperations();
+      return packageOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_versions",
+    label: "Registry Versions",
+    description: "List normalized versions for one package URL",
+    promptSnippet: "Use registries_versions to inspect package releases.",
+    promptGuidelines: ["Use registries_versions when release dates, integrity, or status matter."],
+    parameters: PURLParams,
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { versionsOperation } = await loadToolOperations();
+      return versionsOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_dependencies",
+    label: "Registry Dependencies",
+    description: "List dependencies for a versioned package URL",
+    promptSnippet: "Use registries_dependencies to inspect one package release.",
+    promptGuidelines: [
+      "Use registries_dependencies with a versioned PURL such as pkg:npm/lodash@4.17.21.",
+    ],
+    parameters: PURLParams,
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { dependenciesOperation } = await loadToolOperations();
+      return dependenciesOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_maintainers",
+    label: "Registry Maintainers",
+    description: "List normalized maintainers for one package URL",
+    promptSnippet: "Use registries_maintainers to inspect package ownership.",
+    promptGuidelines: [
+      "Use registries_maintainers to retrieve the identities published by the package registry.",
+    ],
+    parameters: PURLParams,
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { maintainersOperation } = await loadToolOperations();
+      return maintainersOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_bulk_packages",
+    label: "Registry Bulk Packages",
+    description: "Fetch normalized metadata for up to 50 package URLs",
+    promptSnippet: "Use registries_bulk_packages to inspect several packages concurrently.",
+    promptGuidelines: [
+      "Use registries_bulk_packages for independent package lookups; failed packages are absent from the result.",
+    ],
+    parameters: BulkPackagesParams,
+    async execute(_toolCallId, params, signal): Promise<RegistryToolResult> {
+      const { bulkPackagesOperation } = await loadToolOperations();
+      return bulkPackagesOperation(params, signal);
+    },
+  });
+
+  pi.registerTool({
+    name: "registries_ecosystems",
+    label: "Registry Ecosystems",
+    description: "List package ecosystems registered by this package",
+    promptSnippet: "Use registries_ecosystems to discover supported package URL types.",
+    promptGuidelines: [
+      "Use registries_ecosystems before choosing a PURL type when ecosystem support is uncertain.",
+    ],
+    parameters: EmptyParams,
+    async execute(): Promise<RegistryToolResult> {
+      const { ecosystemsOperation } = await loadToolOperations();
+      return ecosystemsOperation();
+    },
+  });
+}

package/dist/_chunks/cached-registry.d.mts

@@ -1,35 +0,0 @@
-import { c as URLBuilder, i as Package, l as Version, n as Dependency, r as Maintainer } from "./types.mjs";
-import { t as Registry } from "./registry.mjs";
-import { Storage } from "unstorage";
-
-//#region src/cache/cached-registry.d.ts
-/**
- * CachedRegistry wraps any Registry and adds caching backed by unstorage
- * with a lockfile for freshness tracking.
- *
- * Pass a custom `storage` to use a non-default driver (e.g. Cloudflare KV).
- * If omitted, uses the globally configured storage (see `configureStorage()`).
- */
-declare class CachedRegistry extends Registry {
-  readonly inner: Registry;
-  readonly storage: Storage;
-  private readonly lockfileStorage;
-  private readonly inflight;
-  constructor(inner: Registry, storage?: Storage);
-  ecosystem(): string;
-  urls(): URLBuilder;
-  fetchPackage(name: string, signal?: AbortSignal): Promise<Package>;
-  fetchVersions(name: string, signal?: AbortSignal): Promise<Version[]>;
-  fetchDependencies(name: string, version: string, signal?: AbortSignal): Promise<Dependency[]>;
-  fetchMaintainers(name: string, signal?: AbortSignal): Promise<Maintainer[]>;
-  /**
-   * Generic cache-through method:
-   * 1. Check lockfile for fresh entry
-   * 2. If fresh -> read from storage
-   * 3. If stale/missing -> fetch, store, update lockfile
-   */
-  private cached;
-}
-//#endregion
-export { CachedRegistry as t };
-//# sourceMappingURL=cached-registry.d.mts.map

package/dist/_chunks/cached-registry.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cached-registry.d.mts","names":[],"sources":["../../src/cache/cached-registry.ts"],"mappings":";;;;;;;AAqBA;;;;;cAAa,cAAA,SAAuB,QAAA;EAAA,SACzB,KAAA,EAAO,QAAA;EAAA,SACP,OAAA,EAAS,OAAA;EAAA,iBACD,eAAA;EAAA,iBACA,QAAA;cAEL,KAAA,EAAO,QAAA,EAAU,OAAA,GAAU,OAAA;EAOvC,SAAA,CAAA;EAIA,IAAA,CAAA,GAAQ,UAAA;EAIF,YAAA,CAAa,IAAA,UAAc,MAAA,GAAS,WAAA,GAAc,OAAA,CAAQ,OAAA;EAW1D,aAAA,CAAc,IAAA,UAAc,MAAA,GAAS,WAAA,GAAc,OAAA,CAAQ,OAAA;EAgB3D,iBAAA,CACJ,IAAA,UACA,OAAA,UACA,MAAA,GAAS,WAAA,GACR,OAAA,CAAQ,UAAA;EAUL,gBAAA,CAAiB,IAAA,UAAc,MAAA,GAAS,WAAA,GAAc,OAAA,CAAQ,UAAA;EAAtB;;;;;;EAAA,QAgBhC,MAAA;AAAA"}

package/dist/_chunks/errors.d.mts

@@ -1,90 +0,0 @@
-import { a as ParsedPURL } from "./types.mjs";
-import { o as Client, t as Registry } from "./registry.mjs";
-
-//#region src/core/purl.d.ts
-/**
- * Parse a PURL string into its components.
- *
- * Format: `pkg:<type>/<namespace>/<name>@<version>?<qualifiers>#<subpath>`
- *
- * @see https://github.com/package-url/purl-spec (ECMA-427)
- */
-declare function parsePURL(purlStr: string): ParsedPURL;
-/** Build the full name from namespace + name (e.g., "@scope/pkg" for npm). */
-declare function fullName(parsed: ParsedPURL): string;
-/** Create a registry instance from a PURL, returning [registry, name, version]. */
-declare function createFromPURL(purlStr: string, client?: Client): [Registry, string, string];
-/** Build a PURL string from components. Inverse of `parsePURL`. */
-declare function buildPURL(parts: {
-  type: string;
-  name: string;
-  version?: string;
-  namespace?: string;
-  qualifiers?: Record<string, string>;
-  subpath?: string;
-}): string;
-//#endregion
-//#region src/core/license.d.ts
-/**
- * Normalize a license string to SPDX expression.
- *
- * Handles common variations: "MIT License" → "MIT", "Apache 2.0" → "Apache-2.0".
- * Passes through already-valid SPDX identifiers unchanged.
- */
-declare function normalizeLicense(raw: string | null | undefined): string;
-/**
- * Combine multiple license strings into a single SPDX expression.
- *
- * Default operator is OR (disjunctive, user picks one).
- * Pass "AND" for ecosystems where multiple licenses mean all apply (e.g. Arch Linux).
- */
-declare function combineLicenses(licenses: (string | null | undefined)[], operator?: "OR" | "AND"): string;
-//#endregion
-//#region src/core/repository.d.ts
-/**
- * Normalize a repository URL to a clean HTTPS git URL.
- *
- * Handles various formats:
- * - "git+https://github.com/foo/bar.git" → "https://github.com/foo/bar"
- * - "git://github.com/foo/bar" → "https://github.com/foo/bar"
- * - "ssh://git@github.com/foo/bar.git" → "https://github.com/foo/bar"
- * - "github:foo/bar" → "https://github.com/foo/bar"
- * - { url: "..." } → extracted and normalized
- */
-declare function normalizeRepositoryURL(raw: unknown): string;
-//#endregion
-//#region src/core/errors.d.ts
-/** Custom error types for registry operations. */
-declare class PkioError extends Error {
-  constructor(message: string, options?: ErrorOptions);
-}
-declare class HTTPError extends PkioError {
-  readonly statusCode: number;
-  readonly url: string;
-  readonly body: string;
-  constructor(statusCode: number, url: string, body: string);
-  isNotFound(): boolean;
-  isRateLimit(): boolean;
-  isServerError(): boolean;
-}
-declare class NotFoundError extends PkioError {
-  readonly ecosystem: string;
-  readonly packageName: string;
-  readonly version: string;
-  constructor(ecosystem: string, packageName: string, version?: string);
-}
-declare class RateLimitError extends PkioError {
-  readonly retryAfter: number;
-  constructor(retryAfter: number);
-}
-declare class UnknownEcosystemError extends PkioError {
-  readonly ecosystem: string;
-  constructor(ecosystem: string);
-}
-declare class InvalidPURLError extends PkioError {
-  readonly purl: string;
-  constructor(purl: string, reason: string);
-}
-//#endregion
-export { RateLimitError as a, combineLicenses as c, createFromPURL as d, fullName as f, PkioError as i, normalizeLicense as l, InvalidPURLError as n, UnknownEcosystemError as o, parsePURL as p, NotFoundError as r, normalizeRepositoryURL as s, HTTPError as t, buildPURL as u };
-//# sourceMappingURL=errors.d.mts.map

package/dist/_chunks/errors.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../../src/core/purl.ts","../../src/core/license.ts","../../src/core/repository.ts","../../src/core/errors.ts"],"mappings":";;;;;AAqBA;;;;;AA4FA;iBA5FgB,SAAA,CAAU,OAAA,WAAkB,UAAA;;iBA4F5B,QAAA,CAAS,MAAA,EAAQ,UAAA;;iBAQjB,cAAA,CAAe,OAAA,UAAiB,MAAA,GAAS,MAAA,IAAU,QAAA;;iBAQnD,SAAA,CAAU,KAAA;EACxB,IAAA;EACA,IAAA;EACA,OAAA;EACA,SAAA;EACA,UAAA,GAAa,MAAA;EACb,OAAA;AAAA;;;;;;;AAlHF;;iBCfgB,gBAAA,CAAiB,GAAA;;;AD2GjC;;;;iBClDgB,eAAA,CACd,QAAA,iCACA,QAAA;;;;;;;AD5CF;;;;;AA4FA;iBEvGgB,sBAAA,CAAuB,GAAA;;;;cCR1B,SAAA,SAAkB,KAAA;cACjB,OAAA,UAAiB,OAAA,GAAU,YAAA;AAAA;AAAA,cAM5B,SAAA,SAAkB,SAAA;EAAA,SACpB,UAAA;EAAA,SACA,GAAA;EAAA,SACA,IAAA;cAEG,UAAA,UAAoB,GAAA,UAAa,IAAA;EAQ7C,UAAA,CAAA;EAIA,WAAA,CAAA;EAIA,aAAA,CAAA;AAAA;AAAA,cAKW,aAAA,SAAsB,SAAA;EAAA,SACxB,SAAA;EAAA,SACA,WAAA;EAAA,SACA,OAAA;cAEG,SAAA,UAAmB,WAAA,UAAqB,OAAA;AAAA;AAAA,cAUzC,cAAA,SAAuB,SAAA;EAAA,SACzB,UAAA;cAEG,UAAA;AAAA;AAAA,cAOD,qBAAA,SAA8B,SAAA;EAAA,SAChC,SAAA;cAEG,SAAA;AAAA;AAAA,cAOD,gBAAA,SAAyB,SAAA;EAAA,SAC3B,IAAA;cAEG,IAAA,UAAc,MAAA;AAAA"}

package/dist/_chunks/lockfile.d.mts

@@ -1,50 +0,0 @@
-import { Storage } from "unstorage";
-
-//#region src/cache/lockfile.d.ts
-/** Default TTL per data type (seconds). */
-declare const DEFAULT_TTL: {
-  readonly package: 3600;
-  readonly versions: 1800;
-  readonly dependencies: 86400;
-  readonly maintainers: 86400;
-};
-type EntryType = keyof typeof DEFAULT_TTL;
-/** A single cached entry tracked in the lockfile. */
-interface LockfileEntry {
-  /** PURL-style key: 'npm:lodash', 'cargo:serde' */
-  key: string;
-  /** What kind of data: package, versions, dependencies, maintainers */
-  type: EntryType;
-  /** Unix timestamp (ms) when fetched */
-  fetchedAt: number;
-  /** TTL in seconds */
-  ttl: number;
-  /** Latest version at time of caching (for package entries) */
-  latestVersion?: string;
-  /** Content hash (sha256 of JSON-serialized value) for integrity */
-  integrity: string;
-}
-/** The full lockfile structure. */
-interface Lockfile {
-  version: number;
-  entries: Record<string, LockfileEntry>;
-}
-/** Read the lockfile from storage. Returns empty lockfile if not found or invalid. */
-declare function readLockfile(storage?: Storage): Promise<Lockfile>;
-/** Write the lockfile to storage. */
-declare function writeLockfile(lockfile: Lockfile, storage?: Storage): Promise<void>;
-/** Build a cache key from ecosystem + name + type + optional version. */
-declare function cacheKey(ecosystem: string, name: string, type: EntryType, version?: string): string;
-/** Check if a lockfile entry is still fresh. */
-declare function isFresh(entry: LockfileEntry): boolean;
-/** Get a lockfile entry if it exists and is fresh. Returns null otherwise. */
-declare function getFreshEntry(lockfile: Lockfile, key: string): LockfileEntry | null;
-/** Upsert an entry in the lockfile. Does NOT persist — call writeLockfile() after. */
-declare function setEntry(lockfile: Lockfile, entry: LockfileEntry): void;
-/** Remove an entry from the lockfile. */
-declare function removeEntry(lockfile: Lockfile, key: string): void;
-/** Remove all stale entries from the lockfile. Returns count of removed entries. */
-declare function pruneStale(lockfile: Lockfile): number;
-//#endregion
-export { cacheKey as a, pruneStale as c, setEntry as d, writeLockfile as f, LockfileEntry as i, readLockfile as l, EntryType as n, getFreshEntry as o, Lockfile as r, isFresh as s, DEFAULT_TTL as t, removeEntry as u };
-//# sourceMappingURL=lockfile.d.mts.map

package/dist/_chunks/lockfile.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lockfile.d.mts","names":[],"sources":["../../src/cache/lockfile.ts"],"mappings":";;;;cAOa,WAAA;EAAA;;;;;KAOD,SAAA,gBAAyB,WAAA;;UAGpB,aAAA;;EAEf,GAAA;EALU;EAOV,IAAA,EAAM,SAAA;;EAEN,SAAA;EAT8C;EAW9C,GAAA;EAR4B;EAU5B,aAAA;EANe;EAQf,SAAA;AAAA;;UAIe,QAAA;EACf,OAAA;EACA,OAAA,EAAS,MAAA,SAAe,aAAA;AAAA;;iBAQJ,YAAA,CAAa,OAAA,GAAU,OAAA,GAAU,OAAA,CAAQ,QAAA;AAV/D;AAAA,iBAsBsB,aAAA,CAAc,QAAA,EAAU,QAAA,EAAU,OAAA,GAAU,OAAA,GAAU,OAAA;;iBAM5D,QAAA,CACd,SAAA,UACA,IAAA,UACA,IAAA,EAAM,SAAA,EACN,OAAA;;iBAOc,OAAA,CAAQ,KAAA,EAAO,aAAA;;iBAMf,aAAA,CAAc,QAAA,EAAU,QAAA,EAAU,GAAA,WAAc,aAAA;;iBAQhD,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,KAAA,EAAO,aAAA;AA3CpD;AAAA,iBAgDgB,WAAA,CAAY,QAAA,EAAU,QAAA,EAAU,GAAA;;iBAKhC,UAAA,CAAW,QAAA,EAAU,QAAA"}

package/dist/_chunks/paths.d.mts

@@ -1,11 +0,0 @@
-//#region src/cache/paths.d.ts
-/**
- * Resolve the cache directory following platform conventions:
- * - Linux: $XDG_CACHE_HOME/registries or ~/.cache/registries
- * - macOS: ~/Library/Caches/registries
- * - Windows: %LOCALAPPDATA%/registries/cache
- */
-declare function getCacheDir(): string;
-//#endregion
-export { getCacheDir as t };
-//# sourceMappingURL=paths.d.mts.map

package/dist/_chunks/paths.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paths.d.mts","names":[],"sources":["../../src/cache/paths.ts"],"mappings":";;AAWA;;;;;iBAAgB,WAAA,CAAA"}

package/dist/_chunks/purl.mjs

@@ -1,192 +0,0 @@
-import { l as InvalidPURLError, n as create } from "./registry.mjs";
-/**
-* Normalize a license string to SPDX expression.
-*
-* Handles common variations: "MIT License" → "MIT", "Apache 2.0" → "Apache-2.0".
-* Passes through already-valid SPDX identifiers unchanged.
-*/
-function normalizeLicense(raw) {
-	if (!raw) return "";
-	const trimmed = raw.trim();
-	if (!trimmed) return "";
-	const lower = trimmed.toLowerCase();
-	const known = LICENSE_MAP.get(lower);
-	if (known) return known;
-	return trimmed;
-}
-const LICENSE_MAP = new Map([
-	["mit license", "MIT"],
-	["mit", "MIT"],
-	["apache license 2.0", "Apache-2.0"],
-	["apache 2.0", "Apache-2.0"],
-	["apache-2.0", "Apache-2.0"],
-	["apache license, version 2.0", "Apache-2.0"],
-	["apache2", "Apache-2.0"],
-	["bsd-2-clause", "BSD-2-Clause"],
-	["bsd-3-clause", "BSD-3-Clause"],
-	["bsd 2-clause", "BSD-2-Clause"],
-	["bsd 3-clause", "BSD-3-Clause"],
-	["simplified bsd license", "BSD-2-Clause"],
-	["new bsd license", "BSD-3-Clause"],
-	["isc license", "ISC"],
-	["isc", "ISC"],
-	["gpl-2.0", "GPL-2.0-only"],
-	["gpl-3.0", "GPL-3.0-only"],
-	["gpl-2.0-only", "GPL-2.0-only"],
-	["gpl-3.0-only", "GPL-3.0-only"],
-	["lgpl-2.1", "LGPL-2.1-only"],
-	["lgpl-3.0", "LGPL-3.0-only"],
-	["mpl-2.0", "MPL-2.0"],
-	["mozilla public license 2.0", "MPL-2.0"],
-	["unlicense", "Unlicense"],
-	["the unlicense", "Unlicense"],
-	["cc0-1.0", "CC0-1.0"],
-	["cc0", "CC0-1.0"],
-	["public domain", "Unlicense"],
-	["zlib", "Zlib"],
-	["wtfpl", "WTFPL"],
-	["artistic-2.0", "Artistic-2.0"],
-	["boost software license 1.0", "BSL-1.0"],
-	["bsl-1.0", "BSL-1.0"]
-]);
-/**
-* Combine multiple license strings into a single SPDX expression.
-*
-* Default operator is OR (disjunctive, user picks one).
-* Pass "AND" for ecosystems where multiple licenses mean all apply (e.g. Arch Linux).
-*/
-function combineLicenses(licenses, operator = "OR") {
-	const normalized = licenses.map((l) => normalizeLicense(l)).filter(Boolean);
-	if (normalized.length === 0) return "";
-	if (normalized.length === 1) return normalized[0];
-	return normalized.join(` ${operator} `);
-}
-/**
-* Normalize a repository URL to a clean HTTPS git URL.
-*
-* Handles various formats:
-* - "git+https://github.com/foo/bar.git" → "https://github.com/foo/bar"
-* - "git://github.com/foo/bar" → "https://github.com/foo/bar"
-* - "ssh://git@github.com/foo/bar.git" → "https://github.com/foo/bar"
-* - "github:foo/bar" → "https://github.com/foo/bar"
-* - { url: "..." } → extracted and normalized
-*/
-function normalizeRepositoryURL(raw) {
-	if (!raw) return "";
-	let url;
-	if (typeof raw === "string") url = raw;
-	else if (typeof raw === "object" && raw !== null) {
-		const obj = raw;
-		if (typeof obj["url"] === "string") url = obj["url"];
-		else return "";
-	} else return "";
-	url = url.trim();
-	if (!url) return "";
-	if (url.startsWith("github:")) url = `https://github.com/${url.slice(7)}`;
-	if (url.startsWith("gitlab:")) url = `https://gitlab.com/${url.slice(7)}`;
-	if (url.startsWith("bitbucket:")) url = `https://bitbucket.org/${url.slice(10)}`;
-	if (url.startsWith("git+")) url = url.slice(4);
-	if (url.startsWith("git://")) url = "https://" + url.slice(6);
-	if (url.startsWith("ssh://git@")) url = "https://" + url.slice(10);
-	const sshMatch = url.match(/^git@([^:]+):(.+)$/);
-	if (sshMatch) url = `https://${sshMatch[1]}/${sshMatch[2]}`;
-	if (url.endsWith("/")) url = url.slice(0, -1);
-	if (url.endsWith(".git")) url = url.slice(0, -4);
-	return url;
-}
-/** Decode a percent-encoded PURL component, throwing InvalidPURLError on malformed sequences. */
-function decodePURLComponent(purlStr, value) {
-	try {
-		return decodeURIComponent(value);
-	} catch {
-		throw new InvalidPURLError(purlStr, "malformed percent-encoding");
-	}
-}
-/**
-* Parse a PURL string into its components.
-*
-* Format: `pkg:<type>/<namespace>/<name>@<version>?<qualifiers>#<subpath>`
-*
-* @see https://github.com/package-url/purl-spec (ECMA-427)
-*/
-function parsePURL(purlStr) {
-	if (!purlStr.startsWith("pkg:")) throw new InvalidPURLError(purlStr, "must start with \"pkg:\"");
-	let remainder = purlStr.slice(4);
-	let subpath = "";
-	const hashIdx = remainder.indexOf("#");
-	if (hashIdx !== -1) {
-		subpath = remainder.slice(hashIdx + 1).split("/").map((s) => decodePURLComponent(purlStr, s)).join("/");
-		remainder = remainder.slice(0, hashIdx);
-	}
-	const qualifiers = {};
-	const queryIdx = remainder.indexOf("?");
-	if (queryIdx !== -1) {
-		const queryStr = remainder.slice(queryIdx + 1);
-		remainder = remainder.slice(0, queryIdx);
-		for (const pair of queryStr.split("&")) {
-			const eqIdx = pair.indexOf("=");
-			if (eqIdx !== -1) qualifiers[decodePURLComponent(purlStr, pair.slice(0, eqIdx))] = decodePURLComponent(purlStr, pair.slice(eqIdx + 1));
-		}
-	}
-	let version = "";
-	const lastSlashBeforeVersion = remainder.lastIndexOf("/");
-	const lastAtIdx = remainder.lastIndexOf("@");
-	if (lastAtIdx !== -1 && lastAtIdx > lastSlashBeforeVersion) {
-		version = decodePURLComponent(purlStr, remainder.slice(lastAtIdx + 1));
-		remainder = remainder.slice(0, lastAtIdx);
-	}
-	const slashIdx = remainder.indexOf("/");
-	if (slashIdx === -1) throw new InvalidPURLError(purlStr, "missing type/name separator");
-	const type = remainder.slice(0, slashIdx).toLowerCase();
-	if (!type) throw new InvalidPURLError(purlStr, "empty type");
-	const rest = remainder.slice(slashIdx + 1);
-	if (!rest) throw new InvalidPURLError(purlStr, "empty name");
-	const lastSlashIdx = rest.lastIndexOf("/");
-	let namespace = "";
-	let name;
-	if (lastSlashIdx !== -1) {
-		namespace = rest.slice(0, lastSlashIdx).split("/").map((s) => decodePURLComponent(purlStr, s)).join("/");
-		name = decodePURLComponent(purlStr, rest.slice(lastSlashIdx + 1));
-	} else name = decodePURLComponent(purlStr, rest);
-	if (type === "pypi") name = name.toLowerCase().replace(/[-_.]+/g, "-");
-	if (type === "alpm") name = name.toLowerCase();
-	return {
-		type,
-		namespace,
-		name,
-		version,
-		qualifiers,
-		subpath
-	};
-}
-/** Build the full name from namespace + name (e.g., "@scope/pkg" for npm). */
-function fullName(parsed) {
-	if (parsed.namespace) return `${parsed.namespace}/${parsed.name}`;
-	return parsed.name;
-}
-/** Create a registry instance from a PURL, returning [registry, name, version]. */
-function createFromPURL(purlStr, client) {
-	const parsed = parsePURL(purlStr);
-	const baseURL = parsed.qualifiers["repository_url"] ?? "";
-	return [
-		create(parsed.type, baseURL || void 0, client),
-		fullName(parsed),
-		parsed.version
-	];
-}
-/** Build a PURL string from components. Inverse of `parsePURL`. */
-function buildPURL(parts) {
-	let purl = `pkg:${parts.type}/`;
-	if (parts.namespace) purl += `${parts.namespace.split("/").map((s) => encodeURIComponent(s)).join("/")}/`;
-	purl += encodeURIComponent(parts.name);
-	if (parts.version) purl += `@${encodeURIComponent(parts.version)}`;
-	if (parts.qualifiers && Object.keys(parts.qualifiers).length > 0) {
-		const qs = Object.entries(parts.qualifiers).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
-		purl += `?${qs}`;
-	}
-	if (parts.subpath) purl += `#${parts.subpath.split("/").map((s) => encodeURIComponent(s)).join("/")}`;
-	return purl;
-}
-export { normalizeRepositoryURL as a, parsePURL as i, createFromPURL as n, combineLicenses as o, fullName as r, normalizeLicense as s, buildPURL as t };
-
-//# sourceMappingURL=purl.mjs.map