@mcptoolshop/registry-stats 0.3.0

package/dist/cli.js

@@ -0,0 +1,880 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { writeFileSync, existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/types.ts
+var RegistryError = class extends Error {
+  constructor(registry, statusCode, message, retryAfter) {
+    super(`[${registry}] ${message}`);
+    this.registry = registry;
+    this.statusCode = statusCode;
+    this.retryAfter = retryAfter;
+    this.name = "RegistryError";
+  }
+};
+
+// src/fetch.ts
+var RETRYABLE = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var MAX_RETRIES = 3;
+var BASE_DELAY = 1e3;
+async function fetchWithRetry(url, registry, init) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    const res = await fetch(url, init);
+    if (res.status === 404) return null;
+    if (res.ok) return res.json();
+    const retryAfter = res.headers.get("retry-after");
+    const retryAfterMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : void 0;
+    lastError = new RegistryError(
+      registry,
+      res.status,
+      `${res.statusText}: ${url}`,
+      retryAfter ? parseInt(retryAfter, 10) : void 0
+    );
+    if (!RETRYABLE.has(res.status) || attempt === MAX_RETRIES) break;
+    const delay = retryAfterMs ?? BASE_DELAY * Math.pow(2, attempt);
+    await new Promise((r) => setTimeout(r, delay));
+  }
+  throw lastError;
+}
+
+// src/providers/npm.ts
+var API = "https://api.npmjs.org/downloads";
+var npm = {
+  name: "npm",
+  async getStats(pkg) {
+    const [day, week, month] = await Promise.all([
+      fetchWithRetry(`${API}/point/last-day/${pkg}`, "npm"),
+      fetchWithRetry(`${API}/point/last-week/${pkg}`, "npm"),
+      fetchWithRetry(`${API}/point/last-month/${pkg}`, "npm")
+    ]);
+    if (!day && !week && !month) return null;
+    return {
+      registry: "npm",
+      package: pkg,
+      downloads: {
+        lastDay: day?.downloads,
+        lastWeek: week?.downloads,
+        lastMonth: month?.downloads
+      },
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  },
+  async getRange(pkg, start, end) {
+    const startDate = new Date(start);
+    const endDate = new Date(end);
+    const maxDays = 549;
+    const chunks = [];
+    let cursor = startDate;
+    while (cursor < endDate) {
+      const chunkEnd = new Date(cursor);
+      chunkEnd.setDate(chunkEnd.getDate() + maxDays - 1);
+      const actualEnd = chunkEnd > endDate ? endDate : chunkEnd;
+      const s = fmt(cursor);
+      const e = fmt(actualEnd);
+      const data = await fetchWithRetry(`${API}/range/${s}:${e}/${pkg}`, "npm");
+      if (data) {
+        for (const d of data.downloads) {
+          chunks.push({ date: d.day, downloads: d.downloads });
+        }
+      }
+      cursor = new Date(actualEnd);
+      cursor.setDate(cursor.getDate() + 1);
+    }
+    return chunks;
+  }
+};
+function fmt(d) {
+  return d.toISOString().slice(0, 10);
+}
+
+// src/providers/pypi.ts
+var API2 = "https://pypistats.org/api";
+var pypi = {
+  name: "pypi",
+  rateLimit: { maxRequests: 30, windowSeconds: 60, authRaisesLimit: false },
+  async getStats(pkg) {
+    const [recent, overall] = await Promise.all([
+      fetchWithRetry(`${API2}/packages/${pkg}/recent`, "pypi"),
+      fetchWithRetry(`${API2}/packages/${pkg}/overall?mirrors=false`, "pypi")
+    ]);
+    if (!recent && !overall) return null;
+    const total = overall?.data?.filter((d) => d.category === "without_mirrors")?.reduce((sum, d) => sum + d.downloads, 0);
+    return {
+      registry: "pypi",
+      package: pkg,
+      downloads: {
+        total: total || void 0,
+        lastDay: recent?.data.last_day,
+        lastWeek: recent?.data.last_week,
+        lastMonth: recent?.data.last_month
+      },
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  },
+  async getRange(pkg, start, end) {
+    const data = await fetchWithRetry(
+      `${API2}/packages/${pkg}/overall?mirrors=false`,
+      "pypi"
+    );
+    if (!data) return [];
+    const startDate = new Date(start);
+    const endDate = new Date(end);
+    return data.data.filter((d) => {
+      if (!d.date || d.category !== "without_mirrors") return false;
+      const date = new Date(d.date);
+      return date >= startDate && date <= endDate;
+    }).map((d) => ({ date: d.date, downloads: d.downloads })).sort((a, b) => a.date.localeCompare(b.date));
+  }
+};
+
+// src/providers/nuget.ts
+var SEARCH_API = "https://azuresearch-usnc.nuget.org/query";
+var nuget = {
+  name: "nuget",
+  async getStats(pkg) {
+    const url = `${SEARCH_API}?q=packageid:${encodeURIComponent(pkg)}&take=1`;
+    const json2 = await fetchWithRetry(url, "nuget");
+    if (!json2) return null;
+    const match = json2.data.find(
+      (d) => d.id.toLowerCase() === pkg.toLowerCase()
+    );
+    if (!match) return null;
+    return {
+      registry: "nuget",
+      package: match.id,
+      downloads: {
+        total: match.totalDownloads
+      },
+      extra: {
+        version: match.version
+      },
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/providers/vscode.ts
+var API3 = "https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery";
+function getStat(stats2, name) {
+  return stats2.find((s) => s.statisticName === name)?.value;
+}
+var vscode = {
+  name: "vscode",
+  async getStats(pkg) {
+    let json2;
+    try {
+      json2 = await fetchWithRetry(API3, "vscode", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json;api-version=3.0-preview.1"
+        },
+        body: JSON.stringify({
+          filters: [
+            {
+              criteria: [{ filterType: 7, value: pkg }]
+            }
+          ],
+          flags: 256
+          // IncludeStatistics
+        })
+      });
+    } catch (e) {
+      if (e.statusCode === 400) return null;
+      throw e;
+    }
+    if (!json2) return null;
+    const ext = json2.results?.[0]?.extensions?.[0];
+    if (!ext) return null;
+    const stats2 = ext.statistics || [];
+    return {
+      registry: "vscode",
+      package: `${ext.publisher.publisherName}.${ext.extensionName}`,
+      downloads: {
+        total: getStat(stats2, "install")
+      },
+      extra: {
+        displayName: ext.displayName,
+        rating: getStat(stats2, "averagerating"),
+        ratingCount: getStat(stats2, "ratingcount"),
+        trendingDaily: getStat(stats2, "trendingdaily"),
+        trendingWeekly: getStat(stats2, "trendingweekly"),
+        trendingMonthly: getStat(stats2, "trendingmonthly")
+      },
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/providers/docker.ts
+var API4 = "https://hub.docker.com/v2/repositories";
+var docker = {
+  name: "docker",
+  rateLimit: { maxRequests: 10, windowSeconds: 3600, authRaisesLimit: true },
+  async getStats(pkg, options) {
+    const headers = {};
+    if (options?.dockerToken) {
+      headers["Authorization"] = `Bearer ${options.dockerToken}`;
+    }
+    const json2 = await fetchWithRetry(`${API4}/${pkg}`, "docker", { headers });
+    if (!json2 || !json2.name || !json2.namespace) return null;
+    return {
+      registry: "docker",
+      package: `${json2.namespace}/${json2.name}`,
+      downloads: {
+        total: json2.pull_count
+      },
+      extra: {
+        stars: json2.star_count,
+        lastUpdated: json2.last_updated
+      },
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/calc.ts
+var calc = {
+  total(records) {
+    return records.reduce((sum, r) => sum + r.downloads, 0);
+  },
+  avg(records) {
+    if (records.length === 0) return 0;
+    return calc.total(records) / records.length;
+  },
+  group(records, fn) {
+    const groups = {};
+    for (const r of records) {
+      const key = fn(r);
+      (groups[key] ??= []).push(r);
+    }
+    return groups;
+  },
+  monthly(records) {
+    return calc.group(records, (r) => r.date.slice(0, 7));
+  },
+  yearly(records) {
+    return calc.group(records, (r) => r.date.slice(0, 4));
+  },
+  groupTotals(grouped) {
+    const result = {};
+    for (const [key, records] of Object.entries(grouped)) {
+      result[key] = calc.total(records);
+    }
+    return result;
+  },
+  groupAvgs(grouped) {
+    const result = {};
+    for (const [key, records] of Object.entries(grouped)) {
+      result[key] = calc.avg(records);
+    }
+    return result;
+  },
+  trend(records, windowDays = 7) {
+    if (records.length < windowDays * 2) {
+      return { slope: 0, direction: "flat", changePercent: 0 };
+    }
+    const sorted = [...records].sort((a, b) => a.date.localeCompare(b.date));
+    const recent = sorted.slice(-windowDays);
+    const previous = sorted.slice(-windowDays * 2, -windowDays);
+    const recentAvg = calc.avg(recent);
+    const previousAvg = calc.avg(previous);
+    const slope = recentAvg - previousAvg;
+    const changePercent = previousAvg === 0 ? 0 : (recentAvg - previousAvg) / previousAvg * 100;
+    const threshold = previousAvg * 0.05;
+    const direction = slope > threshold ? "up" : slope < -threshold ? "down" : "flat";
+    return { slope: Math.round(slope * 100) / 100, direction, changePercent: Math.round(changePercent * 100) / 100 };
+  },
+  movingAvg(records, windowDays = 7) {
+    if (records.length < windowDays) return [];
+    const sorted = [...records].sort((a, b) => a.date.localeCompare(b.date));
+    const result = [];
+    for (let i = windowDays - 1; i < sorted.length; i++) {
+      let sum = 0;
+      for (let j = i - windowDays + 1; j <= i; j++) {
+        sum += sorted[j].downloads;
+      }
+      result.push({
+        date: sorted[i].date,
+        downloads: Math.round(sum / windowDays * 100) / 100
+      });
+    }
+    return result;
+  },
+  popularity(records) {
+    if (records.length === 0) return 0;
+    const sorted = [...records].sort((a, b) => a.date.localeCompare(b.date));
+    const recentDays = Math.min(30, sorted.length);
+    const recent = sorted.slice(-recentDays);
+    const avgDaily = calc.avg(recent);
+    const score = Math.max(0, Math.min(100, Math.log10(Math.max(1, avgDaily)) / 6 * 100));
+    return Math.round(score * 10) / 10;
+  },
+  toCSV(records) {
+    const sorted = [...records].sort((a, b) => a.date.localeCompare(b.date));
+    const lines = ["date,downloads"];
+    for (const r of sorted) {
+      lines.push(`${r.date},${r.downloads}`);
+    }
+    return lines.join("\n");
+  },
+  toChartData(records, label = "downloads") {
+    const sorted = [...records].sort((a, b) => a.date.localeCompare(b.date));
+    return {
+      labels: sorted.map((r) => r.date),
+      datasets: [{ label, data: sorted.map((r) => r.downloads) }]
+    };
+  }
+};
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+var CONFIG_NAME = "registry-stats.config.json";
+function loadConfig(startDir) {
+  let dir = startDir ?? process.cwd();
+  while (true) {
+    const configPath = resolve(dir, CONFIG_NAME);
+    if (existsSync(configPath)) {
+      const raw = readFileSync(configPath, "utf-8");
+      return JSON.parse(raw);
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+var STARTER = `{
+  "registries": ["npm", "pypi", "nuget", "vscode", "docker"],
+  "packages": {
+    "my-package": {
+      "npm": "my-package",
+      "pypi": "my-package"
+    }
+  },
+  "cache": true,
+  "cacheTtlMs": 300000,
+  "concurrency": 5
+}
+`;
+function starterConfig() {
+  return STARTER;
+}
+
+// src/server.ts
+import { createServer as httpCreateServer } from "http";
+function json(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function error(res, message, status = 400) {
+  json(res, { error: message }, status);
+}
+function parseUrl(url) {
+  const [pathname, search] = url.split("?");
+  const path = pathname.replace(/^\/api\//, "/").split("/").filter(Boolean);
+  const query = {};
+  if (search) {
+    for (const pair of search.split("&")) {
+      const [k, v] = pair.split("=");
+      if (k) query[decodeURIComponent(k)] = decodeURIComponent(v ?? "");
+    }
+  }
+  return { path, query };
+}
+function createHandler(opts) {
+  const options = { ...opts };
+  if (!options.cache) {
+    options.cache = createCache();
+  }
+  return async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.method !== "GET") {
+      error(res, "Method not allowed", 405);
+      return;
+    }
+    const { path, query } = parseUrl(req.url ?? "/");
+    try {
+      if (path[0] === "stats") {
+        if (path.length === 2) {
+          const pkg = decodeURIComponent(path[1]);
+          const results = await stats.all(pkg, options);
+          json(res, results);
+          return;
+        }
+        if (path.length >= 3) {
+          const registry = path[1];
+          const pkg = path.slice(2).join("/");
+          const result = await stats(registry, pkg, options);
+          if (!result) {
+            error(res, `Package "${pkg}" not found on ${registry}`, 404);
+            return;
+          }
+          json(res, result);
+          return;
+        }
+      }
+      if (path[0] === "compare" && path.length >= 2) {
+        const pkg = decodeURIComponent(path[1]);
+        const registries = query.registries ? query.registries.split(",") : void 0;
+        const result = await stats.compare(pkg, registries, options);
+        json(res, result);
+        return;
+      }
+      if (path[0] === "range" && path.length >= 3) {
+        const registry = path[1];
+        const pkg = path.slice(2).join("/");
+        const { start, end, format } = query;
+        if (!start || !end) {
+          error(res, "Missing start and end query parameters");
+          return;
+        }
+        const data = await stats.range(registry, pkg, start, end, options);
+        if (format === "csv") {
+          res.writeHead(200, {
+            "Content-Type": "text/csv",
+            "Content-Disposition": `attachment; filename="${pkg}-${start}-${end}.csv"`
+          });
+          res.end(calc.toCSV(data));
+          return;
+        }
+        if (format === "chart") {
+          json(res, calc.toChartData(data, `${pkg} (${registry})`));
+          return;
+        }
+        json(res, data);
+        return;
+      }
+      if (path.length === 0) {
+        json(res, {
+          name: "@mcptoolshop/registry-stats",
+          endpoints: [
+            "GET /stats/:package",
+            "GET /stats/:registry/:package",
+            "GET /compare/:package?registries=npm,pypi",
+            "GET /range/:registry/:package?start=YYYY-MM-DD&end=YYYY-MM-DD&format=json|csv|chart"
+          ]
+        });
+        return;
+      }
+      error(res, "Not found", 404);
+    } catch (e) {
+      error(res, e.message, 500);
+    }
+  };
+}
+function serve(opts) {
+  const port = opts?.port ?? 3e3;
+  const handler = createHandler({
+    cache: opts?.cache !== false ? createCache() : void 0
+  });
+  const server = httpCreateServer(handler);
+  server.listen(port, () => {
+    console.log(`registry-stats server listening on http://localhost:${port}`);
+    console.log(`
+Endpoints:`);
+    console.log(`  GET /stats/:package`);
+    console.log(`  GET /stats/:registry/:package`);
+    console.log(`  GET /compare/:package?registries=npm,pypi`);
+    console.log(`  GET /range/:registry/:package?start=...&end=...&format=json|csv|chart`);
+  });
+  return server;
+}
+
+// src/index.ts
+function createCache() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const entry = store.get(key);
+      if (!entry) return void 0;
+      if (Date.now() > entry.expiresAt) {
+        store.delete(key);
+        return void 0;
+      }
+      return entry.value;
+    },
+    set(key, value, ttlMs) {
+      store.set(key, { value, expiresAt: Date.now() + ttlMs });
+    }
+  };
+}
+function pLimit(concurrency) {
+  let active = 0;
+  const queue = [];
+  function next() {
+    if (queue.length > 0 && active < concurrency) {
+      active++;
+      queue.shift()();
+    }
+  }
+  return (fn) => new Promise((resolve3, reject) => {
+    queue.push(() => {
+      fn().then(resolve3, reject).finally(() => {
+        active--;
+        next();
+      });
+    });
+    next();
+  });
+}
+var providers = {
+  npm,
+  pypi,
+  nuget,
+  vscode,
+  docker
+};
+var DEFAULT_TTL = 3e5;
+async function stats(registry, pkg, options) {
+  const provider = providers[registry];
+  if (!provider) {
+    throw new RegistryError(registry, 0, `Unknown registry "${registry}". Use registerProvider() to add custom registries.`);
+  }
+  const cache = options?.cache;
+  if (cache) {
+    const key = `stats:${registry}:${pkg}`;
+    const cached = cache.get(key);
+    if (cached) return cached;
+    const result = await provider.getStats(pkg, options);
+    if (result) cache.set(key, result, options?.cacheTtlMs ?? DEFAULT_TTL);
+    return result;
+  }
+  return provider.getStats(pkg, options);
+}
+stats.all = async function all(pkg, options) {
+  const results = await Promise.allSettled(
+    Object.values(providers).map((p) => p.getStats(pkg, options))
+  );
+  return results.filter(
+    (r) => r.status === "fulfilled" && r.value !== null
+  ).map((r) => r.value);
+};
+stats.bulk = async function bulk(registry, packages, options) {
+  const provider = providers[registry];
+  if (!provider) {
+    throw new RegistryError(registry, 0, `Unknown registry "${registry}".`);
+  }
+  const concurrency = options?.concurrency ?? 5;
+  const limit = pLimit(concurrency);
+  return Promise.all(packages.map((pkg) => limit(() => stats(registry, pkg, options))));
+};
+stats.range = async function range(registry, pkg, start, end, options) {
+  const provider = providers[registry];
+  if (!provider) {
+    throw new RegistryError(registry, 0, `Unknown registry "${registry}".`);
+  }
+  if (!provider.getRange) {
+    throw new RegistryError(
+      registry,
+      0,
+      `${registry} does not support time-series data. Only npm and pypi support getRange().`
+    );
+  }
+  const cache = options?.cache;
+  if (cache) {
+    const key = `range:${registry}:${pkg}:${start}:${end}`;
+    const cached = cache.get(key);
+    if (cached) return cached;
+    const result = await provider.getRange(pkg, start, end);
+    cache.set(key, result, options?.cacheTtlMs ?? DEFAULT_TTL);
+    return result;
+  }
+  return provider.getRange(pkg, start, end);
+};
+stats.compare = async function compare(pkg, registries, options) {
+  const regs = registries ?? Object.keys(providers);
+  const results = await Promise.allSettled(
+    regs.map(async (reg) => {
+      const result = await stats(reg, pkg, options);
+      return result ? { reg, result } : null;
+    })
+  );
+  const registryMap = {};
+  for (const r of results) {
+    if (r.status === "fulfilled" && r.value) {
+      registryMap[r.value.reg] = r.value.result;
+    }
+  }
+  return {
+    package: pkg,
+    registries: registryMap,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+
+// src/cli.ts
+function usage() {
+  console.log(`
+Usage: registry-stats [package] [options]
+       registry-stats serve [--port 3000]
+
+  If no package is given, reads from registry-stats.config.json.
+
+Options:
+  --registry, -r  Registry to query (npm, pypi, nuget, vscode, docker)
+                  Omit to query all registries
+  --range         Date range for time series (e.g. 2025-01-01:2025-06-30)
+                  Only npm and pypi support this
+  --compare       Compare package across registries side-by-side
+  --format        Output format: table (default), json, csv, chart
+  --init          Create a starter registry-stats.config.json
+  --help, -h      Show this help
+
+Subcommands:
+  serve           Start a REST API server
+    --port        Port to listen on (default: 3000)
+
+Examples:
+  registry-stats express
+  registry-stats express -r npm
+  registry-stats express --compare
+  registry-stats express -r npm --range 2025-01-01:2025-06-30 --format csv
+  registry-stats serve --port 8080
+  registry-stats --init
+  registry-stats                   # fetches all packages from config
+`);
+}
+function formatNumber(n) {
+  if (n === void 0) return "-";
+  return n.toLocaleString("en-US");
+}
+function printStats(s) {
+  const d = s.downloads;
+  const parts = [
+    `  ${s.registry.padEnd(7)} | ${s.package}`
+  ];
+  const metrics = [];
+  if (d.total !== void 0) metrics.push(`total: ${formatNumber(d.total)}`);
+  if (d.lastMonth !== void 0) metrics.push(`month: ${formatNumber(d.lastMonth)}`);
+  if (d.lastWeek !== void 0) metrics.push(`week: ${formatNumber(d.lastWeek)}`);
+  if (d.lastDay !== void 0) metrics.push(`day: ${formatNumber(d.lastDay)}`);
+  if (metrics.length > 0) {
+    parts.push(`           ${metrics.join("  ")}`);
+  }
+  if (s.extra) {
+    const extras = [];
+    if (s.extra.stars !== void 0) extras.push(`stars: ${formatNumber(s.extra.stars)}`);
+    if (s.extra.rating !== void 0) extras.push(`rating: ${s.extra.rating.toFixed(1)}`);
+    if (s.extra.version !== void 0) extras.push(`v${s.extra.version}`);
+    if (extras.length > 0) {
+      parts.push(`           ${extras.join("  ")}`);
+    }
+  }
+  console.log(parts.join("\n"));
+}
+function printComparison(result) {
+  const regs = Object.entries(result.registries);
+  if (regs.length === 0) {
+    console.error(`Package "${result.package}" not found on any registry`);
+    process.exit(1);
+  }
+  console.log(`
+  ${result.package} \u2014 comparison
+`);
+  const cols = regs.map(([r]) => r.padEnd(12));
+  console.log(`  ${"Metric".padEnd(14)}${cols.join("")}`);
+  console.log(`  ${"\u2500".repeat(14 + cols.length * 12)}`);
+  const metrics = ["total", "lastMonth", "lastWeek", "lastDay"];
+  const labels = {
+    total: "Total",
+    lastMonth: "Month",
+    lastWeek: "Week",
+    lastDay: "Day"
+  };
+  for (const m of metrics) {
+    const values = regs.map(([, s]) => {
+      const v = s.downloads[m];
+      return (v !== void 0 ? formatNumber(v) : "-").padEnd(12);
+    });
+    console.log(`  ${labels[m].padEnd(14)}${values.join("")}`);
+  }
+  console.log();
+}
+function buildOptions(config) {
+  const opts = {};
+  if (!config) return opts;
+  if (config.cache !== false) {
+    opts.cache = createCache();
+    opts.cacheTtlMs = config.cacheTtlMs;
+  }
+  if (config.concurrency) opts.concurrency = config.concurrency;
+  if (config.dockerToken) opts.dockerToken = config.dockerToken;
+  return opts;
+}
+async function runConfigPackages(config, format) {
+  const packages = config.packages;
+  if (!packages || Object.keys(packages).length === 0) {
+    console.error("No packages defined in config. Add packages to registry-stats.config.json.");
+    process.exit(1);
+  }
+  const opts = buildOptions(config);
+  const allResults = {};
+  for (const [displayName, registryMap] of Object.entries(packages)) {
+    const results = [];
+    const fetches = Object.entries(registryMap).map(async ([registry, pkgId]) => {
+      try {
+        const result = await stats(registry, pkgId, opts);
+        if (result) results.push(result);
+      } catch {
+      }
+    });
+    await Promise.all(fetches);
+    if (results.length > 0) allResults[displayName] = results;
+  }
+  if (format === "json") {
+    console.log(JSON.stringify(allResults, null, 2));
+    return;
+  }
+  if (Object.keys(allResults).length === 0) {
+    console.error("No results found for any configured packages.");
+    process.exit(1);
+  }
+  for (const [displayName, results] of Object.entries(allResults)) {
+    console.log(`
+  ${displayName}`);
+    console.log(`  ${"\u2500".repeat(displayName.length)}`);
+    for (const r of results) {
+      printStats(r);
+    }
+  }
+  console.log();
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    usage();
+    process.exit(0);
+  }
+  if (args.includes("--init")) {
+    const configPath = resolve2(process.cwd(), "registry-stats.config.json");
+    if (existsSync2(configPath)) {
+      console.error("registry-stats.config.json already exists.");
+      process.exit(1);
+    }
+    writeFileSync(configPath, starterConfig(), "utf-8");
+    console.log("Created registry-stats.config.json");
+    process.exit(0);
+  }
+  if (args[0] === "serve") {
+    let port = 3e3;
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === "--port" && args[i + 1]) {
+        port = parseInt(args[++i], 10);
+      }
+    }
+    serve({ port });
+    return;
+  }
+  let pkg;
+  let registry;
+  let range2;
+  let format = "table";
+  let compare2 = false;
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "--registry" || args[i] === "-r") && args[i + 1]) {
+      registry = args[++i];
+    } else if (args[i] === "--range" && args[i + 1]) {
+      range2 = args[++i];
+    } else if (args[i] === "--format" && args[i + 1]) {
+      format = args[++i];
+    } else if (args[i] === "--json") {
+      format = "json";
+    } else if (args[i] === "--compare") {
+      compare2 = true;
+    } else if (!args[i].startsWith("-") && !pkg) {
+      pkg = args[i];
+    }
+  }
+  const config = loadConfig();
+  if (!pkg) {
+    if (!config) {
+      usage();
+      process.exit(0);
+    }
+    await runConfigPackages(config, format);
+    return;
+  }
+  const opts = buildOptions(config);
+  try {
+    if (compare2) {
+      const registries = registry ? [registry] : void 0;
+      const result = await stats.compare(pkg, registries, opts);
+      if (format === "json") {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        printComparison(result);
+      }
+      return;
+    }
+    if (range2) {
+      const reg = registry ?? "npm";
+      const [start, end] = range2.split(":");
+      if (!start || !end) {
+        console.error("Error: --range must be start:end (e.g. 2025-01-01:2025-06-30)");
+        process.exit(1);
+      }
+      const data = await stats.range(reg, pkg, start, end, opts);
+      if (format === "json") {
+        console.log(JSON.stringify(data, null, 2));
+      } else if (format === "csv") {
+        console.log(calc.toCSV(data));
+      } else if (format === "chart") {
+        console.log(JSON.stringify(calc.toChartData(data, `${pkg} (${reg})`), null, 2));
+      } else {
+        const monthly = calc.groupTotals(calc.monthly(data));
+        const t = calc.trend(data);
+        console.log(`
+${pkg} (${reg}) \u2014 ${start} to ${end}
+`);
+        for (const [month, total] of Object.entries(monthly)) {
+          console.log(`  ${month}  ${formatNumber(total)}`);
+        }
+        console.log(`
+  Total: ${formatNumber(calc.total(data))}  Avg/day: ${formatNumber(Math.round(calc.avg(data)))}  Trend: ${t.direction} (${t.changePercent > 0 ? "+" : ""}${t.changePercent}%)`);
+      }
+    } else if (registry) {
+      const result = await stats(registry, pkg, opts);
+      if (!result) {
+        console.error(`Package "${pkg}" not found on ${registry}`);
+        process.exit(1);
+      }
+      if (format === "json") {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log();
+        printStats(result);
+      }
+    } else {
+      const results = await stats.all(pkg, opts);
+      if (results.length === 0) {
+        console.error(`Package "${pkg}" not found on any registry`);
+        process.exit(1);
+      }
+      if (format === "json") {
+        console.log(JSON.stringify(results, null, 2));
+      } else {
+        console.log();
+        for (const r of results) {
+          printStats(r);
+          console.log();
+        }
+      }
+    }
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+main();