@agntn/registries 0.2.0

package/dist/ai.mjs

@@ -0,0 +1,50 @@
+import "./_chunks/registry.mjs";
+import "./_chunks/purl.mjs";
+import "./_chunks/registries.mjs";
+import { a as fetchVersionsFromPURL, i as fetchPackageFromPURL, n as fetchDependenciesFromPURL, r as fetchMaintainersFromPURL, t as bulkFetchPackages } from "./_chunks/helpers.mjs";
+import { tool } from "ai";
+import { z } from "zod";
+const packageTool = tool({
+	description: "Query package metadata from npm, PyPI, crates.io, RubyGems, Packagist, and Arch Linux using PURLs. Supports package info, versions, dependencies, maintainers, and bulk package metadata lookups.",
+	inputSchema: z.discriminatedUnion("operation", [
+		z.object({
+			operation: z.literal("package"),
+			purl: z.string().describe("Package PURL, for example pkg:npm/lodash or pkg:cargo/serde")
+		}),
+		z.object({
+			operation: z.literal("versions"),
+			purl: z.string().describe("Package PURL, for example pkg:npm/lodash or pkg:cargo/serde")
+		}),
+		z.object({
+			operation: z.literal("dependencies"),
+			purl: z.string().describe("Package PURL including a version, for example pkg:pypi/flask@3.1.1")
+		}),
+		z.object({
+			operation: z.literal("maintainers"),
+			purl: z.string().describe("Package PURL, for example pkg:gem/rails or pkg:composer/laravel/framework")
+		}),
+		z.object({
+			operation: z.literal("bulk-packages"),
+			purls: z.array(z.string()).min(1).max(50).describe("List of package PURLs to fetch in bulk."),
+			concurrency: z.number().int().min(1).max(50).optional().describe("Maximum concurrent lookups. Defaults to 15.")
+		})
+	]),
+	execute: async (input, { abortSignal }) => {
+		switch (input.operation) {
+			case "package": return fetchPackageFromPURL(input.purl, abortSignal);
+			case "versions": return fetchVersionsFromPURL(input.purl, abortSignal);
+			case "dependencies": return fetchDependenciesFromPURL(input.purl, abortSignal);
+			case "maintainers": return fetchMaintainersFromPURL(input.purl, abortSignal);
+			case "bulk-packages": {
+				const results = await bulkFetchPackages(input.purls, {
+					concurrency: input.concurrency,
+					signal: abortSignal
+				});
+				return Object.fromEntries(results);
+			}
+		}
+	}
+});
+export { packageTool };
+
+//# sourceMappingURL=ai.mjs.map

package/dist/ai.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.mjs","names":[],"sources":["../src/ai.ts"],"sourcesContent":["import { tool } from \"ai\";\nimport { z } from \"zod\";\nimport {\n  bulkFetchPackages,\n  fetchDependenciesFromPURL,\n  fetchMaintainersFromPURL,\n  fetchPackageFromPURL,\n  fetchVersionsFromPURL,\n} from \"./helpers.ts\";\nimport \"./registries/index.ts\";\n\nexport const packageTool = tool({\n  description:\n    \"Query package metadata from npm, PyPI, crates.io, RubyGems, Packagist, and Arch Linux using PURLs. Supports package info, versions, dependencies, maintainers, and bulk package metadata lookups.\",\n  inputSchema: z.discriminatedUnion(\"operation\", [\n    z.object({\n      operation: z.literal(\"package\"),\n      purl: z.string().describe(\"Package PURL, for example pkg:npm/lodash or pkg:cargo/serde\"),\n    }),\n    z.object({\n      operation: z.literal(\"versions\"),\n      purl: z.string().describe(\"Package PURL, for example pkg:npm/lodash or pkg:cargo/serde\"),\n    }),\n    z.object({\n      operation: z.literal(\"dependencies\"),\n      purl: z\n        .string()\n        .describe(\"Package PURL including a version, for example pkg:pypi/flask@3.1.1\"),\n    }),\n    z.object({\n      operation: z.literal(\"maintainers\"),\n      purl: z\n        .string()\n        .describe(\"Package PURL, for example pkg:gem/rails or pkg:composer/laravel/framework\"),\n    }),\n    z.object({\n      operation: z.literal(\"bulk-packages\"),\n      purls: z.array(z.string()).min(1).max(50).describe(\"List of package PURLs to fetch in bulk.\"),\n      concurrency: z\n        .number()\n        .int()\n        .min(1)\n        .max(50)\n        .optional()\n        .describe(\"Maximum concurrent lookups. Defaults to 15.\"),\n    }),\n  ]),\n  execute: async (input, { abortSignal }) => {\n    switch (input.operation) {\n      case \"package\":\n        return fetchPackageFromPURL(input.purl, abortSignal);\n      case \"versions\":\n        return fetchVersionsFromPURL(input.purl, abortSignal);\n      case \"dependencies\":\n        return fetchDependenciesFromPURL(input.purl, abortSignal);\n      case \"maintainers\":\n        return fetchMaintainersFromPURL(input.purl, abortSignal);\n      case \"bulk-packages\": {\n        const results = await bulkFetchPackages(input.purls, {\n          concurrency: input.concurrency,\n          signal: abortSignal,\n        });\n        return Object.fromEntries(results);\n      }\n    }\n  },\n});\n"],"mappings":";;;;;;AAWA,MAAa,cAAc,KAAK;CAC9B,aACE;CACF,aAAa,EAAE,mBAAmB,aAAa;EAC7C,EAAE,OAAO;GACP,WAAW,EAAE,QAAQ,UAAU;GAC/B,MAAM,EAAE,QAAQ,CAAC,SAAS,8DAAA;GAC3B,CAAC;EACF,EAAE,OAAO;GACP,WAAW,EAAE,QAAQ,WAAW;GAChC,MAAM,EAAE,QAAQ,CAAC,SAAS,8DAAA;GAC3B,CAAC;EACF,EAAE,OAAO;GACP,WAAW,EAAE,QAAQ,eAAe;GACpC,MAAM,EACH,QAAQ,CACR,SAAS,qEAAA;GACb,CAAC;EACF,EAAE,OAAO;GACP,WAAW,EAAE,QAAQ,cAAc;GACnC,MAAM,EACH,QAAQ,CACR,SAAS,4EAAA;GACb,CAAC;EACF,EAAE,OAAO;GACP,WAAW,EAAE,QAAQ,gBAAgB;GACrC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,CAAC,SAAS,0CAA0C;GAC7F,aAAa,EACV,QAAQ,CACR,KAAK,CACL,IAAI,EAAE,CACN,IAAI,GAAG,CACP,UAAU,CACV,SAAS,8CAAA;GACb,CAAA;EACF,CAAC;CACF,SAAS,OAAO,OAAO,EAAE,kBAAkB;AACzC,UAAQ,MAAM,WAAd;GACE,KAAK,UACH,QAAO,qBAAqB,MAAM,MAAM,YAAY;GACtD,KAAK,WACH,QAAO,sBAAsB,MAAM,MAAM,YAAY;GACvD,KAAK,eACH,QAAO,0BAA0B,MAAM,MAAM,YAAY;GAC3D,KAAK,cACH,QAAO,yBAAyB,MAAM,MAAM,YAAY;GAC1D,KAAK,iBAAiB;IACpB,MAAM,UAAU,MAAM,kBAAkB,MAAM,OAAO;KACnD,aAAa,MAAM;KACnB,QAAQ;KACT,CAAC;AACF,WAAO,OAAO,YAAY,QAAQ;;;;CAIzC,CAAC"}

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

@@ -0,0 +1,4 @@
+import "../_chunks/types.mjs";
+import "../_chunks/registry.mjs";
+import { t as CachedRegistry } from "../_chunks/cached-registry.mjs";
+export { CachedRegistry };

package/dist/cache/cached-registry.mjs

@@ -0,0 +1,92 @@
+import { t as Registry } from "../_chunks/registry.mjs";
+import { computeIntegrity, getStorage } from "./storage.mjs";
+import { DEFAULT_TTL, cacheKey, getFreshEntry, readLockfile, setEntry, writeLockfile } from "./lockfile.mjs";
+/**
+* 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()`).
+*/
+var CachedRegistry = class extends Registry {
+	inner;
+	storage;
+	lockfileStorage;
+	inflight = /* @__PURE__ */ new Map();
+	constructor(inner, storage) {
+		super();
+		this.inner = inner;
+		this.storage = storage ?? getStorage();
+		this.lockfileStorage = storage ?? getStorage();
+	}
+	ecosystem() {
+		return this.inner.ecosystem();
+	}
+	urls() {
+		return this.inner.urls();
+	}
+	async fetchPackage(name, signal) {
+		return this.cached(name, "package", void 0, () => this.inner.fetchPackage(name, signal), signal, (value) => ({ latestVersion: value.latestVersion }));
+	}
+	async fetchVersions(name, signal) {
+		return (await this.cached(name, "versions", void 0, () => this.inner.fetchVersions(name, signal), signal)).map((v) => ({
+			...v,
+			publishedAt: v.publishedAt ? new Date(v.publishedAt) : null
+		}));
+	}
+	async fetchDependencies(name, version, signal) {
+		return this.cached(name, "dependencies", version, () => this.inner.fetchDependencies(name, version, signal), signal);
+	}
+	async fetchMaintainers(name, signal) {
+		return this.cached(name, "maintainers", void 0, () => this.inner.fetchMaintainers(name, signal), signal);
+	}
+	/**
+	* Generic cache-through method:
+	* 1. Check lockfile for fresh entry
+	* 2. If fresh -> read from storage
+	* 3. If stale/missing -> fetch, store, update lockfile
+	*/
+	async cached(name, type, version, fetcher, signal, extraMeta) {
+		const key = cacheKey(this.inner.ecosystem(), name, type, version);
+		const storageKey = key;
+		const entry = getFreshEntry(await readLockfile(this.lockfileStorage), key);
+		if (entry) {
+			const cached = await this.storage.getItem(storageKey);
+			if (cached !== null) {
+				if (computeIntegrity(cached) === entry.integrity) return cached;
+			}
+		}
+		if (!signal) {
+			const pending = this.inflight.get(key);
+			if (pending) return pending;
+		}
+		const flight = (async () => {
+			const value = await fetcher();
+			const meta = extraMeta ? extraMeta(value) : {};
+			const newEntry = {
+				key,
+				type,
+				fetchedAt: Date.now(),
+				ttl: DEFAULT_TTL[type],
+				integrity: computeIntegrity(value),
+				..."latestVersion" in meta ? { latestVersion: meta["latestVersion"] } : {}
+			};
+			try {
+				await this.storage.setItem(storageKey, value);
+				const freshLockfile = await readLockfile(this.lockfileStorage);
+				setEntry(freshLockfile, newEntry);
+				await writeLockfile(freshLockfile, this.lockfileStorage);
+			} catch {}
+			return value;
+		})();
+		if (!signal) this.inflight.set(key, flight);
+		try {
+			return await flight;
+		} finally {
+			if (!signal) this.inflight.delete(key);
+		}
+	}
+};
+export { CachedRegistry };
+
+//# sourceMappingURL=cached-registry.mjs.map

package/dist/cache/cached-registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cached-registry.mjs","names":[],"sources":["../../src/cache/cached-registry.ts"],"sourcesContent":["import type { Dependency, Maintainer, Package, URLBuilder, Version } from \"../core/types.ts\";\nimport { Registry } from \"../core/registry.ts\";\nimport { getStorage, computeIntegrity } from \"./storage.ts\";\nimport {\n  readLockfile,\n  writeLockfile,\n  cacheKey,\n  getFreshEntry,\n  setEntry,\n  DEFAULT_TTL,\n} from \"./lockfile.ts\";\nimport type { EntryType, LockfileEntry } from \"./lockfile.ts\";\nimport type { Storage } from \"unstorage\";\n\n/**\n * CachedRegistry wraps any Registry and adds caching backed by unstorage\n * with a lockfile for freshness tracking.\n *\n * Pass a custom `storage` to use a non-default driver (e.g. Cloudflare KV).\n * If omitted, uses the globally configured storage (see `configureStorage()`).\n */\nexport class CachedRegistry extends Registry {\n  readonly inner: Registry;\n  readonly storage: Storage;\n  private readonly lockfileStorage: Storage;\n  private readonly inflight = new Map<string, Promise<unknown>>();\n\n  constructor(inner: Registry, storage?: Storage) {\n    super();\n    this.inner = inner;\n    this.storage = storage ?? getStorage();\n    this.lockfileStorage = storage ?? getStorage();\n  }\n\n  ecosystem(): string {\n    return this.inner.ecosystem();\n  }\n\n  urls(): URLBuilder {\n    return this.inner.urls();\n  }\n\n  async fetchPackage(name: string, signal?: AbortSignal): Promise<Package> {\n    return this.cached<Package>(\n      name,\n      \"package\",\n      undefined,\n      () => this.inner.fetchPackage(name, signal),\n      signal,\n      (value) => ({ latestVersion: value.latestVersion }),\n    );\n  }\n\n  async fetchVersions(name: string, signal?: AbortSignal): Promise<Version[]> {\n    const versions = await this.cached<Version[]>(\n      name,\n      \"versions\",\n      undefined,\n      () => this.inner.fetchVersions(name, signal),\n      signal,\n    );\n    // JSON round-trip through storage turns Date objects into ISO strings.\n    // Revive them so consumers can safely call .getTime() / .toISOString().\n    return versions.map((v) => ({\n      ...v,\n      publishedAt: v.publishedAt ? new Date(v.publishedAt as unknown as string) : null,\n    }));\n  }\n\n  async fetchDependencies(\n    name: string,\n    version: string,\n    signal?: AbortSignal,\n  ): Promise<Dependency[]> {\n    return this.cached<Dependency[]>(\n      name,\n      \"dependencies\",\n      version,\n      () => this.inner.fetchDependencies(name, version, signal),\n      signal,\n    );\n  }\n\n  async fetchMaintainers(name: string, signal?: AbortSignal): Promise<Maintainer[]> {\n    return this.cached<Maintainer[]>(\n      name,\n      \"maintainers\",\n      undefined,\n      () => this.inner.fetchMaintainers(name, signal),\n      signal,\n    );\n  }\n\n  /**\n   * Generic cache-through method:\n   * 1. Check lockfile for fresh entry\n   * 2. If fresh -> read from storage\n   * 3. If stale/missing -> fetch, store, update lockfile\n   */\n  private async cached<T>(\n    name: string,\n    type: EntryType,\n    version: string | undefined,\n    fetcher: () => Promise<T>,\n    signal: AbortSignal | undefined,\n    extraMeta?: (value: T) => Record<string, unknown>,\n  ): Promise<T> {\n    const eco = this.inner.ecosystem();\n    const key = cacheKey(eco, name, type, version);\n    const storageKey = key;\n\n    // 1. Check lockfile\n    const lockfile = await readLockfile(this.lockfileStorage);\n    const entry = getFreshEntry(lockfile, key);\n\n    if (entry) {\n      // 2. Read from storage\n      const cached = await this.storage.getItem<T>(storageKey);\n      if (cached !== null) {\n        // Verify integrity\n        const currentHash = computeIntegrity(cached);\n        if (currentHash === entry.integrity) {\n          return cached;\n        }\n        // Integrity mismatch - refetch\n      }\n    }\n\n    // 3. Coalesce concurrent fetches for the same key (single-flight).\n    // Skip dedup when caller provides an AbortSignal to avoid sharing\n    // cancellation context across unrelated callers.\n    if (!signal) {\n      const pending = this.inflight.get(key);\n      if (pending) {\n        return pending as Promise<T>;\n      }\n    }\n\n    const flight = (async () => {\n      const value = await fetcher();\n\n      // Persist to cache (best-effort - storage failures must not discard fetched data)\n      const meta = extraMeta ? extraMeta(value) : {};\n      const newEntry: LockfileEntry = {\n        key,\n        type,\n        fetchedAt: Date.now(),\n        ttl: DEFAULT_TTL[type],\n        integrity: computeIntegrity(value),\n        ...(\"latestVersion\" in meta ? { latestVersion: meta[\"latestVersion\"] as string } : {}),\n      };\n      try {\n        await this.storage.setItem(storageKey, value as Record<string, unknown>);\n        // Re-read lockfile before writing to avoid overwriting entries\n        // added by concurrent calls for different keys.\n        const freshLockfile = await readLockfile(this.lockfileStorage);\n        setEntry(freshLockfile, newEntry);\n        await writeLockfile(freshLockfile, this.lockfileStorage);\n      } catch {\n        // Storage I/O failed (disk full, permissions, remote driver timeout, etc.).\n        // The data was already fetched successfully - return it anyway.\n      }\n\n      return value;\n    })();\n\n    if (!signal) {\n      this.inflight.set(key, flight);\n    }\n    try {\n      return await flight;\n    } finally {\n      if (!signal) {\n        this.inflight.delete(key);\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAqBA,IAAa,iBAAb,cAAoC,SAAS;CAC3C;CACA;CACA;CACA,2BAA4B,IAAI,KAA+B;CAE/D,YAAY,OAAiB,SAAmB;AAC9C,SAAO;AACP,OAAK,QAAQ;AACb,OAAK,UAAU,WAAW,YAAY;AACtC,OAAK,kBAAkB,WAAW,YAAY;;CAGhD,YAAoB;AAClB,SAAO,KAAK,MAAM,WAAW;;CAG/B,OAAmB;AACjB,SAAO,KAAK,MAAM,MAAM;;CAG1B,MAAM,aAAa,MAAc,QAAwC;AACvE,SAAO,KAAK,OACV,MACA,WACA,KAAA,SACM,KAAK,MAAM,aAAa,MAAM,OAAO,EAC3C,SACC,WAAW,EAAE,eAAe,MAAM,eAAe,EACnD;;CAGH,MAAM,cAAc,MAAc,QAA0C;AAU1E,UATiB,MAAM,KAAK,OAC1B,MACA,YACA,KAAA,SACM,KAAK,MAAM,cAAc,MAAM,OAAO,EAC5C,OACD,EAGe,KAAK,OAAO;GAC1B,GAAG;GACH,aAAa,EAAE,cAAc,IAAI,KAAK,EAAE,YAAiC,GAAG;GAC7E,EAAE;;CAGL,MAAM,kBACJ,MACA,SACA,QACuB;AACvB,SAAO,KAAK,OACV,MACA,gBACA,eACM,KAAK,MAAM,kBAAkB,MAAM,SAAS,OAAO,EACzD,OACD;;CAGH,MAAM,iBAAiB,MAAc,QAA6C;AAChF,SAAO,KAAK,OACV,MACA,eACA,KAAA,SACM,KAAK,MAAM,iBAAiB,MAAM,OAAO,EAC/C,OACD;;;;;;;;CASH,MAAc,OACZ,MACA,MACA,SACA,SACA,QACA,WACY;EAEZ,MAAM,MAAM,SADA,KAAK,MAAM,WAAW,EACR,MAAM,MAAM,QAAQ;EAC9C,MAAM,aAAa;EAInB,MAAM,QAAQ,cADG,MAAM,aAAa,KAAK,gBAAgB,EACnB,IAAI;AAE1C,MAAI,OAAO;GAET,MAAM,SAAS,MAAM,KAAK,QAAQ,QAAW,WAAW;AACxD,OAAI,WAAW;QAEO,iBAAiB,OAAO,KACxB,MAAM,UACxB,QAAO;;;AASb,MAAI,CAAC,QAAQ;GACX,MAAM,UAAU,KAAK,SAAS,IAAI,IAAI;AACtC,OAAI,QACF,QAAO;;EAIX,MAAM,UAAU,YAAY;GAC1B,MAAM,QAAQ,MAAM,SAAS;GAG7B,MAAM,OAAO,YAAY,UAAU,MAAM,GAAG,EAAE;GAC9C,MAAM,WAA0B;IAC9B;IACA;IACA,WAAW,KAAK,KAAK;IACrB,KAAK,YAAY;IACjB,WAAW,iBAAiB,MAAM;IAClC,GAAI,mBAAmB,OAAO,EAAE,eAAe,KAAK,kBAA4B,GAAG,EAAA;IACpF;AACD,OAAI;AACF,UAAM,KAAK,QAAQ,QAAQ,YAAY,MAAiC;IAGxE,MAAM,gBAAgB,MAAM,aAAa,KAAK,gBAAgB;AAC9D,aAAS,eAAe,SAAS;AACjC,UAAM,cAAc,eAAe,KAAK,gBAAgB;WAClD;AAKR,UAAO;MACL;AAEJ,MAAI,CAAC,OACH,MAAK,SAAS,IAAI,KAAK,OAAO;AAEhC,MAAI;AACF,UAAO,MAAM;YACL;AACR,OAAI,CAAC,OACH,MAAK,SAAS,OAAO,IAAI"}

package/dist/cache/index.d.mts

@@ -0,0 +1,8 @@
+import "../_chunks/types.mjs";
+import "../_chunks/registry.mjs";
+import { t as getCacheDir } from "../_chunks/paths.mjs";
+import { a as getEcosystemStorage, i as disposeStorage, n as computeIntegrity, o as getStorage, r as configureStorage, t as clearStorage } from "../_chunks/storage.mjs";
+import { t as CachedRegistry } from "../_chunks/cached-registry.mjs";
+import { a as cacheKey, c as pruneStale, d as setEntry, f as writeLockfile, i as LockfileEntry, l as readLockfile, n as EntryType, o as getFreshEntry, r as Lockfile, s as isFresh, t as DEFAULT_TTL, u as removeEntry } from "../_chunks/lockfile.mjs";
+import { n as createCached, t as CreateCachedOptions } from "../_chunks/index3.mjs";
+export { CachedRegistry, CreateCachedOptions, DEFAULT_TTL, EntryType, Lockfile, LockfileEntry, cacheKey, clearStorage, computeIntegrity, configureStorage, createCached, disposeStorage, getCacheDir, getEcosystemStorage, getFreshEntry, getStorage, isFresh, pruneStale, readLockfile, removeEntry, setEntry, writeLockfile };

package/dist/cache/index.mjs

@@ -0,0 +1,12 @@
+import { n as create } from "../_chunks/registry.mjs";
+import { getCacheDir } from "./paths.mjs";
+import { clearStorage, computeIntegrity, configureStorage, disposeStorage, getEcosystemStorage, getStorage } from "./storage.mjs";
+import { DEFAULT_TTL, cacheKey, getFreshEntry, isFresh, pruneStale, readLockfile, removeEntry, setEntry, writeLockfile } from "./lockfile.mjs";
+import { CachedRegistry } from "./cached-registry.mjs";
+/** Create a registry instance with caching + lockfile tracking. */
+function createCached(ecosystem, options) {
+	return new CachedRegistry(create(ecosystem, options?.baseURL, options?.client), options?.storage);
+}
+export { CachedRegistry, DEFAULT_TTL, cacheKey, clearStorage, computeIntegrity, configureStorage, createCached, disposeStorage, getCacheDir, getEcosystemStorage, getFreshEntry, getStorage, isFresh, pruneStale, readLockfile, removeEntry, setEntry, writeLockfile };
+
+//# sourceMappingURL=index.mjs.map

package/dist/cache/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/cache/index.ts"],"sourcesContent":["// Cache\nexport { getCacheDir } from \"./paths.ts\";\nexport {\n  getStorage,\n  getEcosystemStorage,\n  computeIntegrity,\n  disposeStorage,\n  clearStorage,\n  configureStorage,\n} from \"./storage.ts\";\nexport { CachedRegistry } from \"./cached-registry.ts\";\nexport {\n  readLockfile,\n  writeLockfile,\n  cacheKey,\n  isFresh,\n  getFreshEntry,\n  setEntry,\n  removeEntry,\n  pruneStale,\n  DEFAULT_TTL,\n} from \"./lockfile.ts\";\nexport type { Lockfile, LockfileEntry, EntryType } from \"./lockfile.ts\";\n\n// Convenience\nimport type { Storage } from \"unstorage\";\nimport type { Client } from \"../core/client.ts\";\nimport { create, type Registry } from \"../core/registry.ts\";\nimport { CachedRegistry } from \"./cached-registry.ts\";\n\n/** Options for creating a cached registry. */\nexport interface CreateCachedOptions {\n  /** Custom base URL for the registry API. */\n  baseURL?: string;\n  /** Custom HTTP client. */\n  client?: Client;\n  /** Custom unstorage instance. Overrides the globally configured storage. */\n  storage?: Storage;\n}\n\n/** Create a registry instance with caching + lockfile tracking. */\nexport function createCached(ecosystem: string, options?: CreateCachedOptions): Registry {\n  const inner = create(ecosystem, options?.baseURL, options?.client);\n  return new CachedRegistry(inner, options?.storage);\n}\n"],"mappings":";;;;;;AAyCA,SAAgB,aAAa,WAAmB,SAAyC;AAEvF,QAAO,IAAI,eADG,OAAO,WAAW,SAAS,SAAS,SAAS,OAAO,EACjC,SAAS,QAAQ"}

package/dist/cache/lockfile.d.mts

@@ -0,0 +1,2 @@
+import { a as cacheKey, c as pruneStale, d as setEntry, f as writeLockfile, i as LockfileEntry, l as readLockfile, n as EntryType, o as getFreshEntry, r as Lockfile, s as isFresh, t as DEFAULT_TTL, u as removeEntry } from "../_chunks/lockfile.mjs";
+export { DEFAULT_TTL, EntryType, Lockfile, LockfileEntry, cacheKey, getFreshEntry, isFresh, pruneStale, readLockfile, removeEntry, setEntry, writeLockfile };

package/dist/cache/lockfile.mjs

@@ -0,0 +1,68 @@
+import { getStorage } from "./storage.mjs";
+const LOCKFILE_VERSION = 1;
+const LOCKFILE_KEY = "__lockfile__";
+/** Default TTL per data type (seconds). */
+const DEFAULT_TTL = {
+	package: 3600,
+	versions: 1800,
+	dependencies: 86400,
+	maintainers: 86400
+};
+function emptyLockfile() {
+	return {
+		version: LOCKFILE_VERSION,
+		entries: {}
+	};
+}
+/** Read the lockfile from storage. Returns empty lockfile if not found or invalid. */
+async function readLockfile(storage) {
+	const s = storage ?? getStorage();
+	try {
+		const data = await s.getItem(LOCKFILE_KEY);
+		if (!data || data.version !== LOCKFILE_VERSION) return emptyLockfile();
+		return data;
+	} catch {
+		return emptyLockfile();
+	}
+}
+/** Write the lockfile to storage. */
+async function writeLockfile(lockfile, storage) {
+	await (storage ?? getStorage()).setItem(LOCKFILE_KEY, lockfile);
+}
+/** Build a cache key from ecosystem + name + type + optional version. */
+function cacheKey(ecosystem, name, type, version) {
+	const base = `${ecosystem}:${name}:${type}`;
+	return version ? `${base}:${version}` : base;
+}
+/** Check if a lockfile entry is still fresh. */
+function isFresh(entry) {
+	const expiresAt = entry.fetchedAt + entry.ttl * 1e3;
+	return Date.now() < expiresAt;
+}
+/** Get a lockfile entry if it exists and is fresh. Returns null otherwise. */
+function getFreshEntry(lockfile, key) {
+	const entry = lockfile.entries[key];
+	if (!entry) return null;
+	if (!isFresh(entry)) return null;
+	return entry;
+}
+/** Upsert an entry in the lockfile. Does NOT persist — call writeLockfile() after. */
+function setEntry(lockfile, entry) {
+	lockfile.entries[entry.key] = entry;
+}
+/** Remove an entry from the lockfile. */
+function removeEntry(lockfile, key) {
+	delete lockfile.entries[key];
+}
+/** Remove all stale entries from the lockfile. Returns count of removed entries. */
+function pruneStale(lockfile) {
+	let removed = 0;
+	for (const key of Object.keys(lockfile.entries)) if (!isFresh(lockfile.entries[key])) {
+		delete lockfile.entries[key];
+		removed++;
+	}
+	return removed;
+}
+export { DEFAULT_TTL, cacheKey, getFreshEntry, isFresh, pruneStale, readLockfile, removeEntry, setEntry, writeLockfile };
+
+//# sourceMappingURL=lockfile.mjs.map

package/dist/cache/lockfile.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockfile.mjs","names":[],"sources":["../../src/cache/lockfile.ts"],"sourcesContent":["import type { Storage } from \"unstorage\";\nimport { getStorage } from \"./storage.ts\";\n\nconst LOCKFILE_VERSION = 1;\nconst LOCKFILE_KEY = \"__lockfile__\";\n\n/** Default TTL per data type (seconds). */\nexport const DEFAULT_TTL = {\n  package: 3600, // 1 hour — package metadata changes rarely\n  versions: 1800, // 30 min — new versions published more often\n  dependencies: 86400, // 24 hours — deps of a specific version never change\n  maintainers: 86400, // 24 hours\n} as const;\n\nexport type EntryType = keyof typeof DEFAULT_TTL;\n\n/** A single cached entry tracked in the lockfile. */\nexport interface LockfileEntry {\n  /** PURL-style key: 'npm:lodash', 'cargo:serde' */\n  key: string;\n  /** What kind of data: package, versions, dependencies, maintainers */\n  type: EntryType;\n  /** Unix timestamp (ms) when fetched */\n  fetchedAt: number;\n  /** TTL in seconds */\n  ttl: number;\n  /** Latest version at time of caching (for package entries) */\n  latestVersion?: string;\n  /** Content hash (sha256 of JSON-serialized value) for integrity */\n  integrity: string;\n}\n\n/** The full lockfile structure. */\nexport interface Lockfile {\n  version: number;\n  entries: Record<string, LockfileEntry>;\n}\n\nfunction emptyLockfile(): Lockfile {\n  return { version: LOCKFILE_VERSION, entries: {} };\n}\n\n/** Read the lockfile from storage. Returns empty lockfile if not found or invalid. */\nexport async function readLockfile(storage?: Storage): Promise<Lockfile> {\n  const s = storage ?? getStorage();\n  try {\n    const data = await s.getItem<Lockfile>(LOCKFILE_KEY);\n    if (!data || data.version !== LOCKFILE_VERSION) return emptyLockfile();\n    return data;\n  } catch {\n    return emptyLockfile();\n  }\n}\n\n/** Write the lockfile to storage. */\nexport async function writeLockfile(lockfile: Lockfile, storage?: Storage): Promise<void> {\n  const s = storage ?? getStorage();\n  await s.setItem(LOCKFILE_KEY, lockfile);\n}\n\n/** Build a cache key from ecosystem + name + type + optional version. */\nexport function cacheKey(\n  ecosystem: string,\n  name: string,\n  type: EntryType,\n  version?: string,\n): string {\n  const base = `${ecosystem}:${name}:${type}`;\n  return version ? `${base}:${version}` : base;\n}\n\n/** Check if a lockfile entry is still fresh. */\nexport function isFresh(entry: LockfileEntry): boolean {\n  const expiresAt = entry.fetchedAt + entry.ttl * 1000;\n  return Date.now() < expiresAt;\n}\n\n/** Get a lockfile entry if it exists and is fresh. Returns null otherwise. */\nexport function getFreshEntry(lockfile: Lockfile, key: string): LockfileEntry | null {\n  const entry = lockfile.entries[key];\n  if (!entry) return null;\n  if (!isFresh(entry)) return null;\n  return entry;\n}\n\n/** Upsert an entry in the lockfile. Does NOT persist — call writeLockfile() after. */\nexport function setEntry(lockfile: Lockfile, entry: LockfileEntry): void {\n  lockfile.entries[entry.key] = entry;\n}\n\n/** Remove an entry from the lockfile. */\nexport function removeEntry(lockfile: Lockfile, key: string): void {\n  delete lockfile.entries[key];\n}\n\n/** Remove all stale entries from the lockfile. Returns count of removed entries. */\nexport function pruneStale(lockfile: Lockfile): number {\n  let removed = 0;\n  for (const key of Object.keys(lockfile.entries)) {\n    if (!isFresh(lockfile.entries[key]!)) {\n      delete lockfile.entries[key];\n      removed++;\n    }\n  }\n  return removed;\n}\n"],"mappings":";AAGA,MAAM,mBAAmB;AACzB,MAAM,eAAe;;AAGrB,MAAa,cAAc;CACzB,SAAS;CACT,UAAU;CACV,cAAc;CACd,aAAa;CACd;AA0BD,SAAS,gBAA0B;AACjC,QAAO;EAAE,SAAS;EAAkB,SAAS,EAAA;EAAI;;;AAInD,eAAsB,aAAa,SAAsC;CACvE,MAAM,IAAI,WAAW,YAAY;AACjC,KAAI;EACF,MAAM,OAAO,MAAM,EAAE,QAAkB,aAAa;AACpD,MAAI,CAAC,QAAQ,KAAK,YAAY,iBAAkB,QAAO,eAAe;AACtE,SAAO;SACD;AACN,SAAO,eAAe;;;;AAK1B,eAAsB,cAAc,UAAoB,SAAkC;AAExF,QADU,WAAW,YAAY,EACzB,QAAQ,cAAc,SAAS;;;AAIzC,SAAgB,SACd,WACA,MACA,MACA,SACQ;CACR,MAAM,OAAO,GAAG,UAAU,GAAG,KAAK,GAAG;AACrC,QAAO,UAAU,GAAG,KAAK,GAAG,YAAY;;;AAI1C,SAAgB,QAAQ,OAA+B;CACrD,MAAM,YAAY,MAAM,YAAY,MAAM,MAAM;AAChD,QAAO,KAAK,KAAK,GAAG;;;AAItB,SAAgB,cAAc,UAAoB,KAAmC;CACnF,MAAM,QAAQ,SAAS,QAAQ;AAC/B,KAAI,CAAC,MAAO,QAAO;AACnB,KAAI,CAAC,QAAQ,MAAM,CAAE,QAAO;AAC5B,QAAO;;;AAIT,SAAgB,SAAS,UAAoB,OAA4B;AACvE,UAAS,QAAQ,MAAM,OAAO;;;AAIhC,SAAgB,YAAY,UAAoB,KAAmB;AACjE,QAAO,SAAS,QAAQ;;;AAI1B,SAAgB,WAAW,UAA4B;CACrD,IAAI,UAAU;AACd,MAAK,MAAM,OAAO,OAAO,KAAK,SAAS,QAAQ,CAC7C,KAAI,CAAC,QAAQ,SAAS,QAAQ,KAAM,EAAE;AACpC,SAAO,SAAS,QAAQ;AACxB;;AAGJ,QAAO"}

package/dist/cache/paths.d.mts

@@ -0,0 +1,2 @@
+import { t as getCacheDir } from "../_chunks/paths.mjs";
+export { getCacheDir };

package/dist/cache/paths.mjs

@@ -0,0 +1,26 @@
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+const APP_NAME = "registries";
+/**
+* Resolve the cache directory following platform conventions:
+* - Linux: $XDG_CACHE_HOME/registries or ~/.cache/registries
+* - macOS: ~/Library/Caches/registries
+* - Windows: %LOCALAPPDATA%/registries/cache
+*/
+function getCacheDir() {
+	const envOverride = process.env["REGISTRIES_CACHE_DIR"];
+	if (envOverride) return envOverride;
+	const os = platform();
+	if (os === "darwin") return join(homedir(), "Library", "Caches", APP_NAME);
+	if (os === "win32") {
+		const localAppData = process.env["LOCALAPPDATA"];
+		if (localAppData) return join(localAppData, APP_NAME, "cache");
+		return join(homedir(), "AppData", "Local", APP_NAME, "cache");
+	}
+	const xdgCache = process.env["XDG_CACHE_HOME"];
+	if (xdgCache) return join(xdgCache, APP_NAME);
+	return join(homedir(), ".cache", APP_NAME);
+}
+export { getCacheDir };
+
+//# sourceMappingURL=paths.mjs.map

package/dist/cache/paths.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.mjs","names":[],"sources":["../../src/cache/paths.ts"],"sourcesContent":["import { homedir, platform } from \"node:os\";\nimport { join } from \"node:path\";\n\nconst APP_NAME = \"registries\";\n\n/**\n * Resolve the cache directory following platform conventions:\n * - Linux: $XDG_CACHE_HOME/registries or ~/.cache/registries\n * - macOS: ~/Library/Caches/registries\n * - Windows: %LOCALAPPDATA%/registries/cache\n */\nexport function getCacheDir(): string {\n  // Explicit override always wins\n  const envOverride = process.env[\"REGISTRIES_CACHE_DIR\"];\n  if (envOverride) return envOverride;\n\n  const os = platform();\n\n  if (os === \"darwin\") {\n    return join(homedir(), \"Library\", \"Caches\", APP_NAME);\n  }\n\n  if (os === \"win32\") {\n    const localAppData = process.env[\"LOCALAPPDATA\"];\n    if (localAppData) return join(localAppData, APP_NAME, \"cache\");\n    return join(homedir(), \"AppData\", \"Local\", APP_NAME, \"cache\");\n  }\n\n  // Linux / FreeBSD / other — XDG Base Directory\n  const xdgCache = process.env[\"XDG_CACHE_HOME\"];\n  if (xdgCache) return join(xdgCache, APP_NAME);\n  return join(homedir(), \".cache\", APP_NAME);\n}\n"],"mappings":";;AAGA,MAAM,WAAW;;;;;;;AAQjB,SAAgB,cAAsB;CAEpC,MAAM,cAAc,QAAQ,IAAI;AAChC,KAAI,YAAa,QAAO;CAExB,MAAM,KAAK,UAAU;AAErB,KAAI,OAAO,SACT,QAAO,KAAK,SAAS,EAAE,WAAW,UAAU,SAAS;AAGvD,KAAI,OAAO,SAAS;EAClB,MAAM,eAAe,QAAQ,IAAI;AACjC,MAAI,aAAc,QAAO,KAAK,cAAc,UAAU,QAAQ;AAC9D,SAAO,KAAK,SAAS,EAAE,WAAW,SAAS,UAAU,QAAQ;;CAI/D,MAAM,WAAW,QAAQ,IAAI;AAC7B,KAAI,SAAU,QAAO,KAAK,UAAU,SAAS;AAC7C,QAAO,KAAK,SAAS,EAAE,UAAU,SAAS"}

package/dist/cache/storage.d.mts

@@ -0,0 +1,2 @@
+import { a as getEcosystemStorage, i as disposeStorage, n as computeIntegrity, o as getStorage, r as configureStorage, t as clearStorage } from "../_chunks/storage.mjs";
+export { clearStorage, computeIntegrity, configureStorage, disposeStorage, getEcosystemStorage, getStorage };

package/dist/cache/storage.mjs

@@ -0,0 +1,40 @@
+import { getCacheDir } from "./paths.mjs";
+import { createStorage, prefixStorage } from "unstorage";
+import fsDriver from "unstorage/drivers/fs";
+import { hash } from "node:crypto";
+let _storage;
+/**
+* Configure a custom unstorage instance for @agntn/registries.
+* Call this before any cache operations to use a non-default driver
+* (e.g. Cloudflare KV, Redis, memory).
+*/
+function configureStorage(storage) {
+	_storage = storage;
+}
+/** Get or create the shared storage instance. Uses configured storage or falls back to fs driver. */
+function getStorage() {
+	if (!_storage) _storage = createStorage({ driver: fsDriver({ base: getCacheDir() }) });
+	return _storage;
+}
+/** Get a namespaced storage for a specific ecosystem (e.g. 'npm', 'cargo'). */
+function getEcosystemStorage(ecosystem) {
+	return prefixStorage(getStorage(), ecosystem);
+}
+/** Compute a sha256 integrity hash of a JSON-serializable value. */
+function computeIntegrity(value) {
+	return `sha256-${hash("sha256", JSON.stringify(value), "hex")}`;
+}
+/** Dispose the storage instance. Call on process exit. */
+async function disposeStorage() {
+	if (_storage) {
+		await _storage.dispose();
+		_storage = void 0;
+	}
+}
+/** Clear all cached data. */
+async function clearStorage() {
+	await getStorage().clear();
+}
+export { clearStorage, computeIntegrity, configureStorage, disposeStorage, getEcosystemStorage, getStorage };
+
+//# sourceMappingURL=storage.mjs.map

package/dist/cache/storage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.mjs","names":[],"sources":["../../src/cache/storage.ts"],"sourcesContent":["import { createStorage, prefixStorage } from \"unstorage\";\nimport fsDriver from \"unstorage/drivers/fs\";\nimport type { Storage } from \"unstorage\";\nimport { getCacheDir } from \"./paths.ts\";\nimport { hash } from \"node:crypto\";\n\nlet _storage: Storage | undefined;\n\n/**\n * Configure a custom unstorage instance for @agntn/registries.\n * Call this before any cache operations to use a non-default driver\n * (e.g. Cloudflare KV, Redis, memory).\n */\nexport function configureStorage(storage: Storage): void {\n  _storage = storage;\n}\n\n/** Get or create the shared storage instance. Uses configured storage or falls back to fs driver. */\nexport function getStorage(): Storage {\n  if (!_storage) {\n    _storage = createStorage({\n      driver: fsDriver({ base: getCacheDir() }),\n    });\n  }\n  return _storage;\n}\n\n/** Get a namespaced storage for a specific ecosystem (e.g. 'npm', 'cargo'). */\nexport function getEcosystemStorage(ecosystem: string): Storage {\n  return prefixStorage(getStorage(), ecosystem);\n}\n\n/** Compute a sha256 integrity hash of a JSON-serializable value. */\nexport function computeIntegrity(value: unknown): string {\n  return `sha256-${hash(\"sha256\", JSON.stringify(value), \"hex\")}`;\n}\n\n/** Dispose the storage instance. Call on process exit. */\nexport async function disposeStorage(): Promise<void> {\n  if (_storage) {\n    await _storage.dispose();\n    _storage = undefined;\n  }\n}\n\n/** Clear all cached data. */\nexport async function clearStorage(): Promise<void> {\n  await getStorage().clear();\n}\n"],"mappings":";;;;AAMA,IAAI;;;;;;AAOJ,SAAgB,iBAAiB,SAAwB;AACvD,YAAW;;;AAIb,SAAgB,aAAsB;AACpC,KAAI,CAAC,SACH,YAAW,cAAc,EACvB,QAAQ,SAAS,EAAE,MAAM,aAAa,EAAE,CAAC,EAC1C,CAAC;AAEJ,QAAO;;;AAIT,SAAgB,oBAAoB,WAA4B;AAC9D,QAAO,cAAc,YAAY,EAAE,UAAU;;;AAI/C,SAAgB,iBAAiB,OAAwB;AACvD,QAAO,UAAU,KAAK,UAAU,KAAK,UAAU,MAAM,EAAE,MAAM;;;AAI/D,eAAsB,iBAAgC;AACpD,KAAI,UAAU;AACZ,QAAM,SAAS,SAAS;AACxB,aAAW,KAAA;;;;AAKf,eAAsB,eAA8B;AAClD,OAAM,YAAY,CAAC,OAAO"}

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+runMain(defineCommand({
+	meta: {
+		name: "registries",
+		version: "0.1.0",
+		description: "Universal package registry client — query npm, PyPI, crates.io, RubyGems, Packagist with a single PURL-native API."
+	},
+	subCommands: {
+		info: () => import("./commands/info.mjs").then((m) => m.default),
+		versions: () => import("./commands/versions.mjs").then((m) => m.default),
+		deps: () => import("./commands/deps.mjs").then((m) => m.default),
+		maintainers: () => import("./commands/maintainers.mjs").then((m) => m.default),
+		cache: () => import("./commands/cache.mjs").then((m) => m.default)
+	}
+}));
+export {};
+
+//# sourceMappingURL=cli.mjs.map

package/dist/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","names":[],"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { defineCommand, runMain } from \"citty\";\n\nconst main = defineCommand({\n  meta: {\n    name: \"registries\",\n    version: \"0.1.0\",\n    description:\n      \"Universal package registry client — query npm, PyPI, crates.io, RubyGems, Packagist with a single PURL-native API.\",\n  },\n  subCommands: {\n    info: () => import(\"./commands/info.ts\").then((m) => m.default),\n    versions: () => import(\"./commands/versions.ts\").then((m) => m.default),\n    deps: () => import(\"./commands/deps.ts\").then((m) => m.default),\n    maintainers: () => import(\"./commands/maintainers.ts\").then((m) => m.default),\n    cache: () => import(\"./commands/cache.ts\").then((m) => m.default),\n  },\n});\n\nrunMain(main);\n"],"mappings":";;AAmBA,QAhBa,cAAc;CACzB,MAAM;EACJ,MAAM;EACN,SAAS;EACT,aACE;EACH;CACD,aAAa;EACX,YAAY,OAAO,uBAAsB,MAAM,MAAM,EAAE,QAAQ;EAC/D,gBAAgB,OAAO,2BAA0B,MAAM,MAAM,EAAE,QAAQ;EACvE,YAAY,OAAO,uBAAsB,MAAM,MAAM,EAAE,QAAQ;EAC/D,mBAAmB,OAAO,8BAA6B,MAAM,MAAM,EAAE,QAAQ;EAC7E,aAAa,OAAO,wBAAuB,MAAM,MAAM,EAAE,QAAA;;CAE5D,CAAC,CAEW"}

package/dist/commands/cache.d.mts

@@ -0,0 +1,7 @@
+import * as citty from "citty";
+
+//#region src/commands/cache.d.ts
+declare const _default: citty.CommandDef<citty.ArgsDef>;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=cache.d.mts.map

package/dist/commands/cache.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.mts","names":[],"sources":["../../src/commands/cache.ts"],"mappings":""}

package/dist/commands/cache.mjs

@@ -0,0 +1,80 @@
+import { getCacheDir } from "../cache/paths.mjs";
+import { clearStorage } from "../cache/storage.mjs";
+import { pruneStale, readLockfile, writeLockfile } from "../cache/lockfile.mjs";
+import { defineCommand } from "citty";
+import consola from "consola";
+var cache_default = defineCommand({
+	meta: {
+		name: "cache",
+		description: "Manage the registries cache"
+	},
+	subCommands: {
+		clear: defineCommand({
+			meta: {
+				name: "clear",
+				description: "Remove all cached data"
+			},
+			async run() {
+				await clearStorage();
+				await writeLockfile({
+					version: 1,
+					entries: {}
+				});
+				consola.success("Cache cleared");
+			}
+		}),
+		path: defineCommand({
+			meta: {
+				name: "path",
+				description: "Show cache directory path"
+			},
+			run() {
+				console.log(getCacheDir());
+			}
+		}),
+		status: defineCommand({
+			meta: {
+				name: "status",
+				description: "Show cache status and entry count"
+			},
+			async run() {
+				const lockfile = await readLockfile();
+				const entries = Object.values(lockfile.entries);
+				const fresh = entries.filter((e) => {
+					const expiresAt = e.fetchedAt + e.ttl * 1e3;
+					return Date.now() < expiresAt;
+				});
+				const stale = entries.length - fresh.length;
+				consola.log("");
+				consola.log(`  \x1b[1mCache status\x1b[0m`);
+				consola.log(`  \x1b[90mDirectory:\x1b[0m  ${getCacheDir()}`);
+				consola.log(`  \x1b[90mEntries:\x1b[0m    ${entries.length} total, ${fresh.length} fresh, ${stale} stale`);
+				consola.log("");
+				if (fresh.length > 0) {
+					const byEco = /* @__PURE__ */ new Map();
+					for (const e of fresh) {
+						const eco = e.key.split(":")[0];
+						byEco.set(eco, (byEco.get(eco) ?? 0) + 1);
+					}
+					for (const [eco, count] of byEco) consola.log(`  \x1b[36m${eco}\x1b[0m: ${count} cached`);
+					consola.log("");
+				}
+			}
+		}),
+		prune: defineCommand({
+			meta: {
+				name: "prune",
+				description: "Remove stale cache entries"
+			},
+			async run() {
+				const lockfile = await readLockfile();
+				const removed = pruneStale(lockfile);
+				await writeLockfile(lockfile);
+				consola.success(`Pruned ${removed} stale entries`);
+			}
+		})
+	}
+});
+export { cache_default as default };
+
+//# sourceMappingURL=cache.mjs.map

package/dist/commands/cache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.mjs","names":[],"sources":["../../src/commands/cache.ts"],"sourcesContent":["import { defineCommand } from \"citty\";\nimport consola from \"consola\";\nimport { getCacheDir } from \"../cache/paths.ts\";\nimport { clearStorage } from \"../cache/storage.ts\";\nimport { readLockfile, writeLockfile, pruneStale } from \"../cache/lockfile.ts\";\n\nexport default defineCommand({\n  meta: {\n    name: \"cache\",\n    description: \"Manage the registries cache\",\n  },\n  subCommands: {\n    clear: defineCommand({\n      meta: {\n        name: \"clear\",\n        description: \"Remove all cached data\",\n      },\n      async run() {\n        await clearStorage();\n        await writeLockfile({ version: 1, entries: {} });\n        consola.success(\"Cache cleared\");\n      },\n    }),\n    path: defineCommand({\n      meta: {\n        name: \"path\",\n        description: \"Show cache directory path\",\n      },\n      run() {\n        console.log(getCacheDir());\n      },\n    }),\n    status: defineCommand({\n      meta: {\n        name: \"status\",\n        description: \"Show cache status and entry count\",\n      },\n      async run() {\n        const lockfile = await readLockfile();\n        const entries = Object.values(lockfile.entries);\n        const fresh = entries.filter((e) => {\n          const expiresAt = e.fetchedAt + e.ttl * 1000;\n          return Date.now() < expiresAt;\n        });\n        const stale = entries.length - fresh.length;\n\n        consola.log(\"\");\n        consola.log(`  \\x1b[1mCache status\\x1b[0m`);\n        consola.log(`  \\x1b[90mDirectory:\\x1b[0m  ${getCacheDir()}`);\n        consola.log(\n          `  \\x1b[90mEntries:\\x1b[0m    ${entries.length} total, ${fresh.length} fresh, ${stale} stale`,\n        );\n        consola.log(\"\");\n\n        if (fresh.length > 0) {\n          // Group by ecosystem\n          const byEco = new Map<string, number>();\n          for (const e of fresh) {\n            const eco = e.key.split(\":\")[0]!;\n            byEco.set(eco, (byEco.get(eco) ?? 0) + 1);\n          }\n          for (const [eco, count] of byEco) {\n            consola.log(`  \\x1b[36m${eco}\\x1b[0m: ${count} cached`);\n          }\n          consola.log(\"\");\n        }\n      },\n    }),\n    prune: defineCommand({\n      meta: {\n        name: \"prune\",\n        description: \"Remove stale cache entries\",\n      },\n      async run() {\n        const lockfile = await readLockfile();\n        const removed = pruneStale(lockfile);\n        await writeLockfile(lockfile);\n        consola.success(`Pruned ${removed} stale entries`);\n      },\n    }),\n  },\n});\n"],"mappings":";;;;;AAMA,IAAA,gBAAe,cAAc;CAC3B,MAAM;EACJ,MAAM;EACN,aAAa;EACd;CACD,aAAa;EACX,OAAO,cAAc;GACnB,MAAM;IACJ,MAAM;IACN,aAAa;IACd;GACD,MAAM,MAAM;AACV,UAAM,cAAc;AACpB,UAAM,cAAc;KAAE,SAAS;KAAG,SAAS,EAAA;KAAI,CAAC;AAChD,YAAQ,QAAQ,gBAAgB;;GAEnC,CAAC;EACF,MAAM,cAAc;GAClB,MAAM;IACJ,MAAM;IACN,aAAa;IACd;GACD,MAAM;AACJ,YAAQ,IAAI,aAAa,CAAC;;GAE7B,CAAC;EACF,QAAQ,cAAc;GACpB,MAAM;IACJ,MAAM;IACN,aAAa;IACd;GACD,MAAM,MAAM;IACV,MAAM,WAAW,MAAM,cAAc;IACrC,MAAM,UAAU,OAAO,OAAO,SAAS,QAAQ;IAC/C,MAAM,QAAQ,QAAQ,QAAQ,MAAM;KAClC,MAAM,YAAY,EAAE,YAAY,EAAE,MAAM;AACxC,YAAO,KAAK,KAAK,GAAG;MACpB;IACF,MAAM,QAAQ,QAAQ,SAAS,MAAM;AAErC,YAAQ,IAAI,GAAG;AACf,YAAQ,IAAI,+BAA+B;AAC3C,YAAQ,IAAI,gCAAgC,aAAa,GAAG;AAC5D,YAAQ,IACN,gCAAgC,QAAQ,OAAO,UAAU,MAAM,OAAO,UAAU,MAAM,QACvF;AACD,YAAQ,IAAI,GAAG;AAEf,QAAI,MAAM,SAAS,GAAG;KAEpB,MAAM,wBAAQ,IAAI,KAAqB;AACvC,UAAK,MAAM,KAAK,OAAO;MACrB,MAAM,MAAM,EAAE,IAAI,MAAM,IAAI,CAAC;AAC7B,YAAM,IAAI,MAAM,MAAM,IAAI,IAAI,IAAI,KAAK,EAAE;;AAE3C,UAAK,MAAM,CAAC,KAAK,UAAU,MACzB,SAAQ,IAAI,aAAa,IAAI,WAAW,MAAM,SAAS;AAEzD,aAAQ,IAAI,GAAG;;;GAGpB,CAAC;EACF,OAAO,cAAc;GACnB,MAAM;IACJ,MAAM;IACN,aAAa;IACd;GACD,MAAM,MAAM;IACV,MAAM,WAAW,MAAM,cAAc;IACrC,MAAM,UAAU,WAAW,SAAS;AACpC,UAAM,cAAc,SAAS;AAC7B,YAAQ,QAAQ,UAAU,QAAQ,gBAAgB;;GAErD,CAAA;;CAEJ,CAAC"}

package/dist/commands/deps.d.mts

@@ -0,0 +1,23 @@
+import * as citty from "citty";
+
+//#region src/commands/deps.d.ts
+declare const _default: citty.CommandDef<{
+  readonly purl: {
+    readonly type: "positional";
+    readonly description: "Package PURL with version (e.g. pkg:npm/lodash@4.17.21, cargo/serde@1.0)";
+    readonly required: true;
+  };
+  readonly json: {
+    readonly type: "boolean";
+    readonly description: "Output as JSON";
+    readonly default: false;
+  };
+  readonly "no-cache": {
+    readonly type: "boolean";
+    readonly description: "Bypass cache, fetch fresh data";
+    readonly default: false;
+  };
+}>;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=deps.d.mts.map

package/dist/commands/deps.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.d.mts","names":[],"sources":["../../src/commands/deps.ts"],"mappings":""}

package/dist/commands/deps.mjs

@@ -0,0 +1,72 @@
+import "../_chunks/registry.mjs";
+import "../_chunks/purl.mjs";
+import "../_chunks/registries.mjs";
+import { resolvePURL, sharedArgs, withErrorHandling } from "./shared.mjs";
+import { defineCommand } from "citty";
+import consola from "consola";
+var deps_default = defineCommand({
+	meta: {
+		name: "deps",
+		description: "List package dependencies"
+	},
+	args: {
+		...sharedArgs,
+		purl: {
+			type: "positional",
+			description: "Package PURL with version (e.g. pkg:npm/lodash@4.17.21, cargo/serde@1.0)",
+			required: true
+		}
+	},
+	async run({ args }) {
+		await withErrorHandling(async () => {
+			const [reg, name, version] = resolvePURL(args.purl, !args["no-cache"]);
+			if (!version) {
+				const pkg = await reg.fetchPackage(name);
+				if (!pkg.latestVersion) {
+					consola.error("PURL must include a version for dependency lookup, and no latest version found.");
+					consola.info("Example: pkg:npm/lodash@4.17.21");
+					process.exit(1);
+				}
+				consola.info(`No version specified, using latest: ${pkg.latestVersion}`);
+				const deps = await reg.fetchDependencies(name, pkg.latestVersion);
+				outputDeps(name, pkg.latestVersion, deps, args.json);
+				return;
+			}
+			outputDeps(name, version, await reg.fetchDependencies(name, version), args.json);
+		});
+	}
+});
+function outputDeps(name, version, deps, json) {
+	if (json) {
+		console.log(JSON.stringify(deps, null, 2));
+		return;
+	}
+	consola.log("");
+	consola.log(`  \x1b[1m${name}@${version}\x1b[0m — ${deps.length} dependenc${deps.length === 1 ? "y" : "ies"}`);
+	consola.log("");
+	const byScope = /* @__PURE__ */ new Map();
+	for (const dep of deps) {
+		const scope = dep.scope || "runtime";
+		if (!byScope.has(scope)) byScope.set(scope, []);
+		byScope.get(scope).push(dep);
+	}
+	const scopeColors = {
+		runtime: "\x1B[32m",
+		development: "\x1B[33m",
+		build: "\x1B[35m",
+		test: "\x1B[36m",
+		optional: "\x1B[90m"
+	};
+	for (const [scope, scopeDeps] of byScope) {
+		const color = scopeColors[scope] ?? "\x1B[0m";
+		consola.log(`  ${color}${scope}\x1b[0m (${scopeDeps.length})`);
+		for (const dep of scopeDeps) {
+			const opt = dep.optional ? " \x1B[90m(optional)\x1B[0m" : "";
+			consola.log(`    ${dep.name} \x1b[90m${dep.requirements}\x1b[0m${opt}`);
+		}
+		consola.log("");
+	}
+}
+export { deps_default as default };
+
+//# sourceMappingURL=deps.mjs.map

package/dist/commands/deps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.mjs","names":[],"sources":["../../src/commands/deps.ts"],"sourcesContent":["import { defineCommand } from \"citty\";\nimport consola from \"consola\";\nimport { sharedArgs, resolvePURL, withErrorHandling } from \"./shared.ts\";\n\nexport default defineCommand({\n  meta: {\n    name: \"deps\",\n    description: \"List package dependencies\",\n  },\n  args: {\n    ...sharedArgs,\n    purl: {\n      type: \"positional\",\n      description: \"Package PURL with version (e.g. pkg:npm/lodash@4.17.21, cargo/serde@1.0)\",\n      required: true,\n    },\n  },\n  async run({ args }) {\n    await withErrorHandling(async () => {\n      const [reg, name, version] = resolvePURL(args.purl, !args[\"no-cache\"]);\n\n      if (!version) {\n        // Try to resolve latest version\n        const pkg = await reg.fetchPackage(name);\n        if (!pkg.latestVersion) {\n          consola.error(\n            \"PURL must include a version for dependency lookup, and no latest version found.\",\n          );\n          consola.info(\"Example: pkg:npm/lodash@4.17.21\");\n          process.exit(1);\n        }\n        consola.info(`No version specified, using latest: ${pkg.latestVersion}`);\n        const deps = await reg.fetchDependencies(name, pkg.latestVersion);\n        outputDeps(name, pkg.latestVersion, deps, args.json);\n        return;\n      }\n\n      const deps = await reg.fetchDependencies(name, version);\n      outputDeps(name, version, deps, args.json);\n    });\n  },\n});\n\nimport type { Dependency } from \"../core/types.ts\";\n\nfunction outputDeps(name: string, version: string, deps: Dependency[], json: boolean): void {\n  if (json) {\n    console.log(JSON.stringify(deps, null, 2));\n    return;\n  }\n\n  consola.log(\"\");\n  consola.log(\n    `  \\x1b[1m${name}@${version}\\x1b[0m — ${deps.length} dependenc${deps.length === 1 ? \"y\" : \"ies\"}`,\n  );\n  consola.log(\"\");\n\n  const byScope = new Map<string, Dependency[]>();\n  for (const dep of deps) {\n    const scope = dep.scope || \"runtime\";\n    if (!byScope.has(scope)) byScope.set(scope, []);\n    byScope.get(scope)!.push(dep);\n  }\n\n  const scopeColors: Record<string, string> = {\n    runtime: \"\\x1b[32m\",\n    development: \"\\x1b[33m\",\n    build: \"\\x1b[35m\",\n    test: \"\\x1b[36m\",\n    optional: \"\\x1b[90m\",\n  };\n\n  for (const [scope, scopeDeps] of byScope) {\n    const color = scopeColors[scope] ?? \"\\x1b[0m\";\n    consola.log(`  ${color}${scope}\\x1b[0m (${scopeDeps.length})`);\n    for (const dep of scopeDeps) {\n      const opt = dep.optional ? \" \\x1b[90m(optional)\\x1b[0m\" : \"\";\n      consola.log(`    ${dep.name} \\x1b[90m${dep.requirements}\\x1b[0m${opt}`);\n    }\n    consola.log(\"\");\n  }\n}\n"],"mappings":";;;;;;AAIA,IAAA,eAAe,cAAc;CAC3B,MAAM;EACJ,MAAM;EACN,aAAa;EACd;CACD,MAAM;EACJ,GAAG;EACH,MAAM;GACJ,MAAM;GACN,aAAa;GACb,UAAU;;EAEb;CACD,MAAM,IAAI,EAAE,QAAQ;AAClB,QAAM,kBAAkB,YAAY;GAClC,MAAM,CAAC,KAAK,MAAM,WAAW,YAAY,KAAK,MAAM,CAAC,KAAK,YAAY;AAEtE,OAAI,CAAC,SAAS;IAEZ,MAAM,MAAM,MAAM,IAAI,aAAa,KAAK;AACxC,QAAI,CAAC,IAAI,eAAe;AACtB,aAAQ,MACN,kFACD;AACD,aAAQ,KAAK,kCAAkC;AAC/C,aAAQ,KAAK,EAAE;;AAEjB,YAAQ,KAAK,uCAAuC,IAAI,gBAAgB;IACxE,MAAM,OAAO,MAAM,IAAI,kBAAkB,MAAM,IAAI,cAAc;AACjE,eAAW,MAAM,IAAI,eAAe,MAAM,KAAK,KAAK;AACpD;;AAIF,cAAW,MAAM,SADJ,MAAM,IAAI,kBAAkB,MAAM,QAAQ,EACvB,KAAK,KAAK;IAC1C;;CAEL,CAAC;AAIF,SAAS,WAAW,MAAc,SAAiB,MAAoB,MAAqB;AAC1F,KAAI,MAAM;AACR,UAAQ,IAAI,KAAK,UAAU,MAAM,MAAM,EAAE,CAAC;AAC1C;;AAGF,SAAQ,IAAI,GAAG;AACf,SAAQ,IACN,YAAY,KAAK,GAAG,QAAQ,YAAY,KAAK,OAAO,YAAY,KAAK,WAAW,IAAI,MAAM,QAC3F;AACD,SAAQ,IAAI,GAAG;CAEf,MAAM,0BAAU,IAAI,KAA2B;AAC/C,MAAK,MAAM,OAAO,MAAM;EACtB,MAAM,QAAQ,IAAI,SAAS;AAC3B,MAAI,CAAC,QAAQ,IAAI,MAAM,CAAE,SAAQ,IAAI,OAAO,EAAE,CAAC;AAC/C,UAAQ,IAAI,MAAM,CAAE,KAAK,IAAI;;CAG/B,MAAM,cAAsC;EAC1C,SAAS;EACT,aAAa;EACb,OAAO;EACP,MAAM;EACN,UAAU;EACX;AAED,MAAK,MAAM,CAAC,OAAO,cAAc,SAAS;EACxC,MAAM,QAAQ,YAAY,UAAU;AACpC,UAAQ,IAAI,KAAK,QAAQ,MAAM,WAAW,UAAU,OAAO,GAAG;AAC9D,OAAK,MAAM,OAAO,WAAW;GAC3B,MAAM,MAAM,IAAI,WAAW,+BAA+B;AAC1D,WAAQ,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,aAAa,SAAS,MAAM;;AAEzE,UAAQ,IAAI,GAAG"}