lurqrun 0.1.6 → 0.1.7

package/dist/chunk-M6NYEXCW.js

@@ -0,0 +1,38 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  apiSurfaces,
+  packages
+} from "./chunk-LYMPYETA.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/db/apiSurfaces.ts
+init_esm_shims();
+import { and, eq, isNotNull, isNull, sql } from "drizzle-orm";
+async function getStoredSurface(db, packageName, version) {
+  const [row] = await db.select({ surface: apiSurfaces.surface }).from(apiSurfaces).where(and(eq(apiSurfaces.packageName, packageName), eq(apiSurfaces.version, version))).limit(1);
+  return row?.surface ?? null;
+}
+async function upsertSurface(db, packageName, version, surface) {
+  await db.insert(apiSurfaces).values({ packageName, version, surface }).onConflictDoUpdate({
+    target: [apiSurfaces.packageName, apiSurfaces.version],
+    set: { surface, extractedAt: /* @__PURE__ */ new Date() }
+  });
+}
+async function getPackagesWithSurface(db, limit = 100) {
+  const rows = await db.select({ name: packages.name, version: packages.latestVersion }).from(packages).innerJoin(
+    apiSurfaces,
+    and(
+      eq(apiSurfaces.packageName, packages.name),
+      eq(apiSurfaces.version, packages.latestVersion)
+    )
+  ).where(isNotNull(packages.latestVersion)).orderBy(sql`random()`).limit(limit);
+  return rows.filter((r) => r.version !== null);
+}
+
+export {
+  getStoredSurface,
+  upsertSurface,
+  getPackagesWithSurface
+};

package/dist/chunk-MHUEVBVO.js

@@ -0,0 +1,35 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/core/errors.ts
+init_esm_shims();
+var DEFAULT_MAX = 300;
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}\u2026`;
+}
+function causeText(cause) {
+  if (cause == null) return null;
+  if (cause instanceof Error) {
+    const code = "code" in cause && (typeof cause.code === "string" || typeof cause.code === "number") ? String(cause.code) : null;
+    const msg = truncate(cause.message, DEFAULT_MAX);
+    return code ? `${code}: ${msg}` : msg;
+  }
+  if (typeof cause === "object" && cause !== null && "message" in cause) {
+    const msg = truncate(String(cause.message), DEFAULT_MAX);
+    const code = "code" in cause ? String(cause.code) : null;
+    return code ? `${code}: ${msg}` : msg;
+  }
+  return truncate(String(cause), DEFAULT_MAX);
+}
+function formatError(err, max = DEFAULT_MAX) {
+  const message = err instanceof Error ? truncate(err.message, max) : truncate(String(err), max);
+  const cause = err instanceof Error ? causeText(err.cause) : null;
+  return cause ? `${message} (cause: ${cause})` : message;
+}
+
+export {
+  formatError
+};

package/dist/chunk-MYGSLK44.js

@@ -0,0 +1,37 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/core/logger.ts
+init_esm_shims();
+var LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+function currentLevel() {
+  const raw = process.env.LOG_LEVEL;
+  return raw && raw in LEVELS ? LEVELS[raw] : LEVELS.info;
+}
+function emit(level, args) {
+  if (LEVELS[level] > currentLevel()) return;
+  const parts = args.map(
+    (a) => typeof a === "string" ? a : a instanceof Error ? a.stack ?? a.message : safeStringify(a)
+  );
+  process.stderr.write(`[lurq] ${level.toUpperCase()} ${parts.join(" ")}
+`);
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var logger = {
+  error: (...args) => emit("error", args),
+  warn: (...args) => emit("warn", args),
+  info: (...args) => emit("info", args),
+  debug: (...args) => emit("debug", args)
+};
+
+export {
+  logger
+};

package/dist/chunk-NH5I4KHH.js

@@ -0,0 +1,201 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  DEFAULT_ECOSYSTEM
+} from "./chunk-VLRHFMGJ.js";
+import {
+  packageVersions,
+  packages,
+  seedPackages,
+  syncRuns
+} from "./chunk-LYMPYETA.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/db/packages.ts
+init_esm_shims();
+import { and, desc, eq, gte, inArray, isNotNull, isNull, lt, notExists, sql } from "drizzle-orm";
+var VERSION_CHUNK = 500;
+var NAME_CHUNK = 500;
+async function getSeedTargets(db) {
+  const rows = await db.select({ name: seedPackages.name, category: seedPackages.category }).from(seedPackages);
+  return rows.map((r) => ({ name: r.name, category: r.category ?? null }));
+}
+async function getStaleRefreshTargets(db, limit) {
+  if (limit <= 0) return [];
+  const rows = await db.select({
+    name: packages.name,
+    category: sql`case when ${packages.categorySource} = 'curated' then ${packages.category} end`
+  }).from(packages).where(
+    notExists(
+      db.select({ one: sql`1` }).from(seedPackages).where(eq(seedPackages.name, packages.name))
+    )
+  ).orderBy(sql`${packages.dataAsOf} asc nulls first`).limit(limit);
+  return rows.map((r) => ({ name: r.name, category: r.category ?? null }));
+}
+async function getPackageByName(db, name, ecosystem = DEFAULT_ECOSYSTEM) {
+  const rows = await db.select().from(packages).where(and(eq(packages.name, name), eq(packages.ecosystem, ecosystem))).limit(1);
+  return rows[0] ?? null;
+}
+async function latestVersionsFor(db, names, ecosystem = DEFAULT_ECOSYSTEM) {
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < names.length; i += NAME_CHUNK) {
+    const rows = await db.select({ name: packages.name, latestVersion: packages.latestVersion }).from(packages).where(
+      and(
+        inArray(packages.name, names.slice(i, i + NAME_CHUNK)),
+        eq(packages.ecosystem, ecosystem)
+      )
+    );
+    for (const row of rows) out.set(row.name, row.latestVersion);
+  }
+  return out;
+}
+async function reusableFieldsFor(db, names, ecosystem = DEFAULT_ECOSYSTEM) {
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < names.length; i += NAME_CHUNK) {
+    const rows = await db.select({
+      name: packages.name,
+      latestVersion: packages.latestVersion,
+      summary: packages.summary,
+      usageGuide: packages.usageGuide,
+      embedding: packages.embedding,
+      embeddingProvider: packages.embeddingProvider
+    }).from(packages).where(
+      and(
+        inArray(packages.name, names.slice(i, i + NAME_CHUNK)),
+        eq(packages.ecosystem, ecosystem)
+      )
+    );
+    for (const row of rows) {
+      const { name, ...fields } = row;
+      out.set(name, fields);
+    }
+  }
+  return out;
+}
+async function getAllPackageNames(db, ecosystem = DEFAULT_ECOSYSTEM) {
+  const rows = await db.select({ name: packages.name }).from(packages).where(eq(packages.ecosystem, ecosystem));
+  return rows.map((r) => r.name);
+}
+async function getPackageNamesCreatedSince(db, since) {
+  const rows = await db.select({ name: packages.name }).from(packages).where(gte(packages.createdAt, since));
+  return rows.map((r) => r.name);
+}
+async function upsertPackageVersions(db, name, versions) {
+  if (versions.length === 0) {
+    logger.debug(`no version timeline to store for ${name}: registry returned none`);
+    return;
+  }
+  for (let i = 0; i < versions.length; i += VERSION_CHUNK) {
+    const rows = versions.slice(i, i + VERSION_CHUNK).map((v) => ({
+      packageName: name,
+      version: v.version,
+      publishedAt: v.publishedAt,
+      peerDependencies: v.peerDependencies ?? null,
+      engines: v.engines ?? null
+    }));
+    await db.insert(packageVersions).values(rows).onConflictDoNothing();
+  }
+}
+async function getPackageVersions(db, name, limit = 50) {
+  const rows = await db.select({ version: packageVersions.version, publishedAt: packageVersions.publishedAt }).from(packageVersions).where(eq(packageVersions.packageName, name)).orderBy(desc(packageVersions.publishedAt)).limit(limit);
+  return rows.map((r) => ({ version: r.version, publishedAt: r.publishedAt }));
+}
+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({
+    target: [packages.ecosystem, packages.name],
+    set: { ...mutable, updatedAt: /* @__PURE__ */ new Date() }
+  });
+}
+async function stampFirstRequester(db, name, ownerId, ecosystem = DEFAULT_ECOSYSTEM) {
+  await db.update(packages).set({ firstRequestedByOwnerId: ownerId }).where(
+    and(
+      eq(packages.name, name),
+      eq(packages.ecosystem, ecosystem),
+      isNull(packages.firstRequestedByOwnerId)
+    )
+  );
+}
+async function getContributionsByOwner(db, ownerId, opts = {}) {
+  const limit = opts.limit ?? 50;
+  const offset = opts.offset ?? 0;
+  const [rows, [countRow]] = await Promise.all([
+    db.select({
+      name: packages.name,
+      category: packages.category,
+      healthScore: packages.healthScore,
+      firstRequestedAt: packages.createdAt
+    }).from(packages).where(eq(packages.firstRequestedByOwnerId, ownerId)).orderBy(desc(packages.createdAt)).limit(limit).offset(offset),
+    db.select({ count: sql`count(*)::int` }).from(packages).where(eq(packages.firstRequestedByOwnerId, ownerId))
+  ]);
+  return { total: countRow?.count ?? 0, packages: rows };
+}
+function syncOrigin() {
+  const env = process.env.RAILWAY_ENVIRONMENT_NAME;
+  const service = process.env.RAILWAY_SERVICE_NAME;
+  if (!env && !service) return null;
+  return `${env ?? "?"}/${service ?? "?"}`;
+}
+var SYNC_STALE_MS = 6 * 60 * 60 * 1e3;
+async function reapAbandonedSyncRuns(db) {
+  await db.update(syncRuns).set({
+    status: "failed",
+    finishedAt: /* @__PURE__ */ new Date(),
+    errors: [
+      {
+        package: "*",
+        source: "pipeline",
+        message: "abandoned: the process died before writing a terminal status"
+      }
+    ]
+  }).where(
+    and(
+      eq(syncRuns.status, "running"),
+      lt(syncRuns.startedAt, new Date(Date.now() - SYNC_STALE_MS))
+    )
+  );
+}
+async function startSyncRun(db) {
+  await reapAbandonedSyncRuns(db);
+  const [row] = await db.insert(syncRuns).values({ status: "running", origin: syncOrigin() }).returning({ id: syncRuns.id });
+  return row.id;
+}
+async function finishSyncRun(db, id, data) {
+  await db.update(syncRuns).set({
+    finishedAt: /* @__PURE__ */ new Date(),
+    packagesSeen: data.packagesSeen,
+    packagesUpdated: data.packagesUpdated,
+    errors: data.errors,
+    status: data.status
+  }).where(eq(syncRuns.id, id));
+}
+
+export {
+  getSeedTargets,
+  getStaleRefreshTargets,
+  getPackageByName,
+  latestVersionsFor,
+  reusableFieldsFor,
+  getAllPackageNames,
+  getPackageNamesCreatedSince,
+  upsertPackageVersions,
+  getPackageVersions,
+  getTopPackageNames,
+  ensureSeedEntry,
+  upsertPackage,
+  stampFirstRequester,
+  getContributionsByOwner,
+  startSyncRun,
+  finishSyncRun
+};