@mcptoolshop/registry-stats 0.3.0

package/dist/index.cjs

@@ -0,0 +1,669 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RegistryError: () => RegistryError,
+  calc: () => calc,
+  createCache: () => createCache,
+  createHandler: () => createHandler,
+  defaultConfig: () => defaultConfig,
+  loadConfig: () => loadConfig,
+  registerProvider: () => registerProvider,
+  serve: () => serve,
+  starterConfig: () => starterConfig,
+  stats: () => stats
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var CONFIG_NAME = "registry-stats.config.json";
+function loadConfig(startDir) {
+  let dir = startDir ?? process.cwd();
+  while (true) {
+    const configPath = (0, import_node_path.resolve)(dir, CONFIG_NAME);
+    if ((0, import_node_fs.existsSync)(configPath)) {
+      const raw = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+      return JSON.parse(raw);
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function defaultConfig() {
+  return {
+    registries: ["npm", "pypi", "nuget", "vscode", "docker"],
+    packages: {},
+    cache: true,
+    cacheTtlMs: 3e5,
+    concurrency: 5
+  };
+}
+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
+var import_node_http = require("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 = (0, import_node_http.createServer)(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((resolve2, reject) => {
+    queue.push(() => {
+      fn().then(resolve2, reject).finally(() => {
+        active--;
+        next();
+      });
+    });
+    next();
+  });
+}
+var providers = {
+  npm,
+  pypi,
+  nuget,
+  vscode,
+  docker
+};
+function registerProvider(provider) {
+  providers[provider.name] = provider;
+}
+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()
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RegistryError,
+  calc,
+  createCache,
+  createHandler,
+  defaultConfig,
+  loadConfig,
+  registerProvider,
+  serve,
+  starterConfig,
+  stats
+});