lurqrun 0.1.7 → 0.1.9

package/dist/chunk-64YOP5BQ.js

@@ -0,0 +1,320 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  handleDiffSurface
+} from "./chunk-JJCQVOC6.js";
+import {
+  getPackageByName
+} from "./chunk-75LMEMJ3.js";
+import {
+  enqueueSurface
+} from "./chunk-ZJ5XHA77.js";
+import {
+  packages,
+  surfaceQueue
+} from "./chunk-6353IJJ5.js";
+import {
+  require_semver
+} from "./chunk-3GHJR7XR.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/mcp/publicUpgrades.ts
+init_esm_shims();
+var import_semver = __toESM(require_semver(), 1);
+import { and as and2, count, desc as desc2, gte, isNotNull as isNotNull2, sql } from "drizzle-orm";
+
+// src/mcp/publicSet.ts
+init_esm_shims();
+import { and, desc, isNotNull } from "drizzle-orm";
+var PUBLIC_TOP_LIMIT = 5e3;
+var NPM_NAME = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
+function validPackageName(name) {
+  return name.length > 0 && name.length <= 214 && NPM_NAME.test(name);
+}
+var floor = null;
+async function publicDownloadFloor(db) {
+  if (floor && Date.now() - floor.at < 36e5) return floor.value;
+  const rows = await db.select({ downloads: packages.weeklyDownloads }).from(packages).where(and(isNotNull(packages.weeklyDownloads), isNotNull(packages.healthScore))).orderBy(desc(packages.weeklyDownloads)).offset(PUBLIC_TOP_LIMIT - 1).limit(1);
+  floor = { at: Date.now(), value: Number(rows[0]?.downloads ?? 0) };
+  return floor.value;
+}
+async function publicPackageRow(db, name) {
+  const [row, min] = await Promise.all([getPackageByName(db, name), publicDownloadFloor(db)]);
+  if (!row || row.healthScore === null || (row.weeklyDownloads ?? 0) < min) return null;
+  return row;
+}
+
+// src/mcp/publicUpgrades.ts
+var PAIRS_PER_PACKAGE = 3;
+var LIST_CAP = 500;
+function majorPairs(latest, keep = PAIRS_PER_PACKAGE) {
+  const sorted = [...latest].sort((a, b) => a.major - b.major);
+  const pairs = [];
+  for (let i = 1; i < sorted.length; i++) {
+    const from = sorted[i - 1];
+    const to = sorted[i];
+    pairs.push({
+      fromMajor: from.major,
+      toMajor: to.major,
+      fromVersion: from.version,
+      toVersion: to.version,
+      ready: from.stored && to.stored
+    });
+  }
+  return pairs.slice(-keep);
+}
+function unextractedSides(latest, keep = PAIRS_PER_PACKAGE) {
+  if (latest.length < 2) return [];
+  const involved = [...latest].sort((a, b) => a.major - b.major).slice(-(keep + 1));
+  return involved.reverse().filter((l) => !l.stored && !l.attempted).map((l) => l.version);
+}
+function upgradeVerdict(d) {
+  if (d.inconclusive) return "unknown";
+  if (d.removed.length > 0 || d.renamed.length > 0) return "removes-exports";
+  if (d.arityChanged.length > 0) return "arity-changed";
+  if (d.typeOnlyRemoved.length > 0) return "types-only";
+  return "clean";
+}
+function toPublicUpgrade(pkg, pair, diff) {
+  const renamedPaths = new Set(diff.renamed.map((r) => r.path));
+  const removed = diff.removed.filter((r) => !renamedPaths.has(r.path));
+  const lists = [
+    removed,
+    diff.renamed,
+    diff.arityChanged,
+    diff.typeOnlyRemoved,
+    diff.deprecated
+  ];
+  const cap = (xs) => xs.slice(0, LIST_CAP);
+  return {
+    package: pkg,
+    pair,
+    status: "ready",
+    verdict: upgradeVerdict({ ...diff, removed }),
+    removed: cap(removed.map((r) => ({ path: r.path, kind: r.kind }))),
+    renamed: cap(diff.renamed),
+    arityChanged: cap(diff.arityChanged),
+    typeOnlyRemoved: cap(diff.typeOnlyRemoved),
+    deprecated: cap(diff.deprecated),
+    added: diff.added.length,
+    truncated: lists.some((l) => l.length > LIST_CAP),
+    tier: diff.tier ?? null,
+    inconclusive: diff.inconclusive ?? null,
+    observedAt: diff.observedAt ? new Date(diff.observedAt).toISOString() : null
+  };
+}
+function pendingUpgrade(pkg, pair) {
+  return {
+    package: pkg,
+    pair,
+    status: "pending",
+    verdict: "unknown",
+    removed: [],
+    renamed: [],
+    arityChanged: [],
+    typeOnlyRemoved: [],
+    deprecated: [],
+    added: 0,
+    truncated: false,
+    tier: null,
+    inconclusive: "Both versions are queued for extraction. NOT evidence that nothing changed.",
+    observedAt: null
+  };
+}
+function rowsOf(result) {
+  return result.rows ?? result;
+}
+async function latestOfMajors(db, names) {
+  const out = /* @__PURE__ */ new Map();
+  if (names.length === 0) return out;
+  const result = await db.execute(sql`
+    with stable as (
+      select package_name, version, (regexp_match(version, '^([0-9]+)\\.'))[1]::int as major
+      from package_versions
+      where package_name in (${sql.join(
+    names.map((n) => sql`${n}`),
+    sql`, `
+  )})
+        -- Stable releases only: an upgrade does not land on a prerelease.
+        and version ~ '^[0-9]+\\.[0-9]+\\.[0-9]+$'
+    ),
+    latest as (
+      select distinct on (package_name, major) package_name, major, version
+      from stable
+      -- Numeric, not lexical (16.10.0 is newer than 16.9.0), and numeric rather
+      -- than int so a date-stamped version cannot overflow the cast.
+      order by package_name, major, string_to_array(version, '.')::numeric[] desc
+    )
+    select
+      l.package_name,
+      l.major,
+      l.version,
+      exists (
+        select 1 from entities e
+        join symbols s on s.entity_id = e.id and s.tier = 'shipped_js_ast'
+        where e.canonical_key = 'package_surface:npm:' || l.package_name || ':' || l.version
+          and e.tenant_id = 0
+      ) as stored,
+      exists (
+        select 1 from entities e
+        where e.canonical_key = 'package_surface:npm:' || l.package_name || ':' || l.version
+          and e.tenant_id = 0
+      ) as attempted
+    from latest l
+  `);
+  for (const r of rowsOf(result)) {
+    const list = out.get(r.package_name) ?? [];
+    list.push({
+      major: Number(r.major),
+      version: r.version,
+      stored: Boolean(r.stored),
+      attempted: Boolean(r.attempted)
+    });
+    out.set(r.package_name, list);
+  }
+  return out;
+}
+async function upgradePairsFor(db, name) {
+  return majorPairs((await latestOfMajors(db, [name])).get(name) ?? []);
+}
+async function upgradeGuideFor(db, pkg, fromVersion, toVersion, webUrl) {
+  const from = import_semver.default.coerce(fromVersion)?.major;
+  const to = import_semver.default.coerce(toVersion)?.major;
+  if (from === void 0 || to === void 0 || to <= from) return null;
+  if (!await publicPackageRow(db, pkg)) return null;
+  const pair = (await upgradePairsFor(db, pkg)).find(
+    (p) => p.fromMajor === from && p.toMajor === to && p.ready
+  );
+  if (!pair) return null;
+  const path = `/npm/${pkg.split("/").map(encodeURIComponent).join("/")}/${from}-to-${to}`;
+  return {
+    url: `${webUrl.replace(/\/$/, "")}${path}`,
+    fromVersion: pair.fromVersion,
+    toVersion: pair.toVersion
+  };
+}
+async function publicNames(db, limit = PUBLIC_TOP_LIMIT) {
+  const min = await publicDownloadFloor(db);
+  const rows = await db.select({ name: packages.name }).from(packages).where(and2(isNotNull2(packages.healthScore), gte(packages.weeklyDownloads, min))).orderBy(desc2(packages.weeklyDownloads)).limit(limit);
+  return rows.map((r) => r.name);
+}
+var QUEUE_HEADROOM = 20;
+async function enqueuePublicUpgrades(db, opts = {}) {
+  const [{ pending } = { pending: 0 }] = await db.select({ pending: count() }).from(surfaceQueue);
+  let budget = QUEUE_HEADROOM - Number(pending);
+  if (budget <= 0) return 0;
+  const names = await publicNames(db, opts.packages ?? 1e3);
+  let queued = 0;
+  for (let i = 0; i < names.length && budget > 0; i += 250) {
+    const chunk = names.slice(i, i + 250);
+    const latest = await latestOfMajors(db, chunk);
+    for (const name of chunk) {
+      for (const version of unextractedSides(latest.get(name) ?? [])) {
+        if (budget <= 0) break;
+        await enqueueSurface(db, name, version);
+        queued++;
+        budget--;
+      }
+      if (budget <= 0) break;
+    }
+  }
+  return queued;
+}
+function registerPublicUpgradeRoutes(app, db, limiter) {
+  const cacheable = (res) => res.setHeader("Cache-Control", "public, max-age=3600, s-maxage=86400");
+  app.get("/public/upgrade", limiter, async (req, res) => {
+    const name = typeof req.query.name === "string" ? req.query.name.trim() : "";
+    const from = Number(req.query.from);
+    const to = Number(req.query.to);
+    if (!validPackageName(name) || !Number.isInteger(from) || !Number.isInteger(to) || from < 0 || to <= from) {
+      res.status(400).json({ error: "Give an npm package name and two majors, from < to." });
+      return;
+    }
+    try {
+      if (!await publicPackageRow(db, name)) {
+        res.status(404).json({ error: "No public upgrade pages for that package." });
+        return;
+      }
+      const pairs = await upgradePairsFor(db, name);
+      const pair = pairs.find((p) => p.fromMajor === from && p.toMajor === to);
+      if (!pair) {
+        res.status(404).json({ error: "No upgrade page for that version jump.", pairs });
+        return;
+      }
+      if (!pair.ready) {
+        await Promise.all([
+          enqueueSurface(db, name, pair.fromVersion),
+          enqueueSurface(db, name, pair.toVersion)
+        ]).catch(() => {
+        });
+        res.setHeader("Cache-Control", "public, max-age=300, s-maxage=900");
+        res.json(pendingUpgrade(name, pair));
+        return;
+      }
+      const diff = await handleDiffSurface(db, {
+        package: name,
+        fromVersion: pair.fromVersion,
+        toVersion: pair.toVersion
+      });
+      const body = toPublicUpgrade(name, pair, diff);
+      if (body.verdict === "unknown")
+        res.setHeader("Cache-Control", "public, max-age=300, s-maxage=900");
+      else cacheable(res);
+      res.json(body);
+    } catch (err) {
+      logger.error("public upgrade read failed:", err instanceof Error ? err.message : String(err));
+      res.status(500).json({ error: "Could not read that upgrade." });
+    }
+  });
+  let index = null;
+  app.get("/public/upgrades", limiter, async (_req, res) => {
+    try {
+      if (!index || Date.now() - index.at > 36e5) {
+        const names = await publicNames(db);
+        const value = [];
+        for (let i = 0; i < names.length; i += 500) {
+          const chunk = names.slice(i, i + 500);
+          const latest = await latestOfMajors(db, chunk);
+          for (const name of chunk) {
+            const ready = majorPairs(latest.get(name) ?? []).filter((p) => p.ready);
+            if (ready.length) value.push({ package: name, pairs: ready });
+          }
+        }
+        index = { at: Date.now(), value };
+      }
+      cacheable(res);
+      res.json({ upgrades: index.value });
+    } catch (err) {
+      logger.error(
+        "public upgrade index failed:",
+        err instanceof Error ? err.message : String(err)
+      );
+      res.status(500).json({ error: "Could not list upgrade pages." });
+    }
+  });
+}
+
+export {
+  PUBLIC_TOP_LIMIT,
+  validPackageName,
+  publicDownloadFloor,
+  publicPackageRow,
+  PAIRS_PER_PACKAGE,
+  LIST_CAP,
+  majorPairs,
+  unextractedSides,
+  upgradeVerdict,
+  toPublicUpgrade,
+  pendingUpgrade,
+  latestOfMajors,
+  upgradePairsFor,
+  upgradeGuideFor,
+  QUEUE_HEADROOM,
+  enqueuePublicUpgrades,
+  registerPublicUpgradeRoutes
+};

package/dist/{chunk-2VMOWSRY.js → chunk-6DM6UQFD.js}

@@ -115,12 +115,29 @@ var FIELD = {
   /** Reports at or above this cap the confidence note as fully-evidenced. */
   wellEvidencedReports: 25
 };
+var DISCOVERY = {
+  /** A queued candidate must clear this quality pre-score to graduate to ingest. */
+  minPreScore: 45,
+  /** Max candidates fully ingested per crawler run (cost bound). */
+  perRunCap: 25,
+  /** npm-search hits to pull per category keyword. */
+  searchSizePerCategory: 10,
+  /** Max dependency-graph neighbors to enqueue per tracked seed. */
+  graphNeighborsPerSeed: 20,
+  /** Ingest failures a candidate gets before it is marked `failed` and stops
+   *  being retried. Three, because the failures worth retrying are transient
+   *  (a registry 5xx, a GitHub rate limit) and clear within an hour or two,
+   *  while the ones that are not — a manifest we cannot parse — would otherwise
+   *  re-buy an LLM summary every cycle for as long as the crawler runs. */
+  maxIngestAttempts: 3
+};
 var DEFAULT_WEIGHTS = {
   health: { ...HEALTH_WEIGHTS },
   composite: { ...COMPOSITE }
 };
 function activeWeightsPath() {
-  if (existsSync(projectWeightsPath())) return { path: projectWeightsPath(), source: "project-config" };
+  if (existsSync(projectWeightsPath()))
+    return { path: projectWeightsPath(), source: "project-config" };
   if (existsSync(userWeightsPath())) return { path: userWeightsPath(), source: "user-config" };
   return null;
 }
@@ -288,6 +305,7 @@ export {
   RELIABILITY,
   EFFICIENCY,
   FIELD,
+  DISCOVERY,
   activeWeightsPath,
   loadWeights,
   validateWeights,

package/dist/{chunk-NH5I4KHH.js → chunk-75LMEMJ3.js}

@@ -7,7 +7,7 @@ import {
   packages,
   seedPackages,
   syncRuns
-} from "./chunk-LYMPYETA.js";
+} from "./chunk-6353IJJ5.js";
 import {
   logger
 } from "./chunk-MYGSLK44.js";
@@ -108,9 +108,6 @@ async function getTopPackageNames(db, limit = 1e3) {
   const rows = await db.select({ name: packages.name }).from(packages).where(isNotNull(packages.weeklyDownloads)).orderBy(desc(packages.weeklyDownloads)).limit(limit);
   return rows.map((r) => r.name);
 }
-async function ensureSeedEntry(db, name, category) {
-  await db.insert(seedPackages).values({ name, category }).onConflictDoNothing({ target: seedPackages.name });
-}
 async function upsertPackage(db, row) {
   const { name: _name, ecosystem: _ecosystem, createdAt: _createdAt, ...mutable } = row;
   await db.insert(packages).values(row).onConflictDoUpdate({
@@ -192,7 +189,6 @@ export {
   upsertPackageVersions,
   getPackageVersions,
   getTopPackageNames,
-  ensureSeedEntry,
   upsertPackage,
   stampFirstRequester,
   getContributionsByOwner,