lurqrun 0.0.1

package/dist/bin/lurq.js

@@ -0,0 +1,2848 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/core/constants.ts
+var SERVER_NAME, PACKAGE_NAME, VERSION, EMBEDDING_DIM, STALENESS_DAYS, HOUR, DAY, CACHE_TTL;
+var init_constants = __esm({
+  "src/core/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    SERVER_NAME = "lurq";
+    PACKAGE_NAME = "lurqrun";
+    VERSION = "0.0.1";
+    EMBEDDING_DIM = 1536;
+    STALENESS_DAYS = 7;
+    HOUR = 60 * 60 * 1e3;
+    DAY = 24 * HOUR;
+    CACHE_TTL = {
+      npmRegistry: 6 * HOUR,
+      npmDownloads: 12 * HOUR,
+      github: 12 * HOUR,
+      depsDev: 24 * HOUR,
+      bundlephobia: 7 * DAY
+    };
+  }
+});
+
+// src/core/types.ts
+function isCategory(value) {
+  return CATEGORIES.includes(value);
+}
+function isFrontendCategory(category) {
+  return category != null && FRONTEND_CATEGORIES.includes(category);
+}
+var CATEGORIES, FRONTEND_CATEGORIES;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    "use strict";
+    init_esm_shims();
+    CATEGORIES = [
+      "framework",
+      "meta-framework",
+      "state-management",
+      "routing",
+      "orm",
+      "database-client",
+      "ui-component-library",
+      "styling",
+      "forms",
+      "validation",
+      "data-fetching",
+      "http-client",
+      "auth",
+      "testing",
+      "build-tool",
+      "bundler",
+      "linting",
+      "date-time",
+      "animation",
+      "charts",
+      "i18n",
+      "utility",
+      "other"
+    ];
+    FRONTEND_CATEGORIES = [
+      "ui-component-library",
+      "styling",
+      "state-management",
+      "forms",
+      "validation",
+      "data-fetching",
+      "charts",
+      "animation",
+      "date-time",
+      "utility"
+    ];
+  }
+});
+
+// src/core/config.ts
+import { config as dotenvConfig } from "dotenv";
+import { z } from "zod";
+function loadEnv() {
+  if (envLoaded) return;
+  dotenvConfig();
+  envLoaded = true;
+}
+function getConfig() {
+  if (cached) return cached;
+  loadEnv();
+  const parsed = EnvSchema.safeParse(process.env);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ConfigError(`Invalid environment configuration:
+${issues}`);
+  }
+  cached = parsed.data;
+  return cached;
+}
+function requireConfig(keys) {
+  const config = getConfig();
+  const missing = keys.filter((k) => config[k] === void 0 || config[k] === "");
+  if (missing.length > 0) {
+    throw new ConfigError(
+      `Missing required environment variable(s): ${missing.join(", ")}.
+See .env.example for setup. Tip: copy it to .env and fill in the values.`
+    );
+  }
+  return config;
+}
+var envLoaded, EnvSchema, ConfigError, cached;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    envLoaded = false;
+    EnvSchema = z.object({
+      DATABASE_URL: z.string().min(1).optional(),
+      GITHUB_TOKEN: z.string().min(1).optional(),
+      EMBEDDING_PROVIDER: z.enum(["openai", "local"]).default("openai"),
+      EMBEDDING_API_KEY: z.string().min(1).optional(),
+      EMBEDDING_MODEL: z.string().min(1).default("text-embedding-3-small"),
+      SUMMARY_PROVIDER: z.enum(["openai", "none"]).default("openai"),
+      SUMMARY_API_KEY: z.string().min(1).optional(),
+      SUMMARY_MODEL: z.string().min(1).default("gpt-4o-mini"),
+      LURQ_SYNC_CONCURRENCY: z.coerce.number().int().positive().max(50).default(5),
+      LOG_LEVEL: z.enum(["error", "warn", "info", "debug"]).default("info")
+    });
+    ConfigError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+      }
+    };
+  }
+});
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  packages: () => packages,
+  seedPackages: () => seedPackages,
+  syncRuns: () => syncRuns
+});
+import {
+  bigint,
+  boolean,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  real,
+  serial,
+  text,
+  timestamp,
+  vector
+} from "drizzle-orm/pg-core";
+var ts, packages, syncRuns, seedPackages;
+var init_schema = __esm({
+  "src/db/schema.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    ts = (name) => timestamp(name, { withTimezone: true, mode: "date" });
+    packages = pgTable(
+      "packages",
+      {
+        id: serial("id").primaryKey(),
+        name: text("name").notNull().unique(),
+        ecosystem: text("ecosystem").notNull().default("npm"),
+        // Classification + descriptive text
+        category: text("category").$type(),
+        description: text("description"),
+        summary: text("summary"),
+        repoUrl: text("repo_url"),
+        homepage: text("homepage"),
+        latestVersion: text("latest_version"),
+        license: text("license"),
+        // Lifecycle flags
+        deprecated: boolean("deprecated").notNull().default(false),
+        archived: boolean("archived").notNull().default(false),
+        // Age / maintenance signals
+        firstPublishedAt: ts("first_published_at"),
+        lastReleaseAt: ts("last_release_at"),
+        // Adoption signals
+        weeklyDownloads: bigint("weekly_downloads", { mode: "number" }),
+        downloadGrowth90d: real("download_growth_90d"),
+        dependentsCount: integer("dependents_count"),
+        stars: integer("stars"),
+        openIssues: integer("open_issues"),
+        closedIssues: integer("closed_issues"),
+        // Reliability / efficiency signals
+        scorecard: real("scorecard"),
+        bundleMinGzipKb: real("bundle_min_gzip_kb"),
+        advisories: jsonb("advisories").$type(),
+        // Computed outputs
+        healthScore: integer("health_score"),
+        confidence: text("confidence").$type(),
+        scoreBreakdown: jsonb("score_breakdown").$type(),
+        usageGuide: jsonb("usage_guide").$type(),
+        embedding: vector("embedding", { dimensions: EMBEDDING_DIM }),
+        // Freshness + bookkeeping
+        dataAsOf: timestamp("data_as_of", { withTimezone: true, mode: "date" }),
+        createdAt: ts("created_at").notNull().defaultNow(),
+        updatedAt: ts("updated_at").notNull().defaultNow()
+      },
+      (table2) => [
+        index("packages_category_idx").on(table2.category),
+        index("packages_health_score_idx").on(table2.healthScore),
+        // pgvector HNSW index for cosine similarity search (§11).
+        index("packages_embedding_idx").using("hnsw", table2.embedding.op("vector_cosine_ops"))
+      ]
+    );
+    syncRuns = pgTable("sync_runs", {
+      id: serial("id").primaryKey(),
+      startedAt: ts("started_at").notNull().defaultNow(),
+      finishedAt: ts("finished_at"),
+      packagesSeen: integer("packages_seen").notNull().default(0),
+      packagesUpdated: integer("packages_updated").notNull().default(0),
+      errors: jsonb("errors").$type().notNull().default([]),
+      status: text("status").$type().notNull().default("running")
+    });
+    seedPackages = pgTable("seed_packages", {
+      name: text("name").primaryKey(),
+      category: text("category").$type(),
+      addedAt: ts("added_at").notNull().defaultNow()
+    });
+  }
+});
+
+// src/db/client.ts
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+function createDb(opts = {}) {
+  const { DATABASE_URL } = requireConfig(["DATABASE_URL"]);
+  const sql6 = postgres(DATABASE_URL, { max: opts.max ?? 10, onnotice: () => {
+  } });
+  const db = drizzle(sql6, { schema: schema_exports });
+  return { db, sql: sql6, close: () => sql6.end() };
+}
+var init_client = __esm({
+  "src/db/client.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_schema();
+  }
+});
+
+// src/core/logger.ts
+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 LEVELS, logger;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+    logger = {
+      error: (...args) => emit("error", args),
+      warn: (...args) => emit("warn", args),
+      info: (...args) => emit("info", args),
+      debug: (...args) => emit("debug", args)
+    };
+  }
+});
+
+// src/core/http.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function limiterFor(host) {
+  let limiter = limiters.get(host);
+  if (!limiter) {
+    limiter = new HostLimiter(HOST_CONFIG[host] ?? DEFAULT_HOST_CONFIG);
+    limiters.set(host, limiter);
+  }
+  return limiter;
+}
+function setCacheBypassRead(value) {
+  bypassCacheRead = value;
+}
+function cacheDir() {
+  return process.env.LURQ_CACHE_DIR ?? join(homedir(), ".cache", "lurq", "http");
+}
+function cacheFile(key) {
+  const hash = createHash("sha256").update(key).digest("hex");
+  return join(cacheDir(), `${hash}.json`);
+}
+async function readCache(key, ttlMs) {
+  const now = Date.now();
+  const mem = memoryCache.get(key);
+  if (mem && now - mem.fetchedAt < ttlMs) return mem;
+  const file = cacheFile(key);
+  if (!existsSync(file)) return void 0;
+  try {
+    const entry = JSON.parse(await readFile(file, "utf8"));
+    if (now - entry.fetchedAt < ttlMs) {
+      memoryCache.set(key, entry);
+      return entry;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function writeCache(key, entry) {
+  memoryCache.set(key, entry);
+  const file = cacheFile(key);
+  try {
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(entry), "utf8");
+  } catch (err) {
+    logger.debug(`http cache write failed: ${err.message}`);
+  }
+}
+async function httpRequest(url, opts) {
+  const {
+    host,
+    ttlMs,
+    method = "GET",
+    headers = {},
+    body,
+    accept = "json",
+    timeoutMs = 15e3,
+    retries = 3,
+    fetchImpl = fetch
+  } = opts;
+  const key = opts.cacheKey ?? `${method} ${url} ${body ?? ""}`;
+  if (ttlMs > 0 && !bypassCacheRead) {
+    const cached2 = await readCache(key, ttlMs);
+    if (cached2) {
+      return { status: cached2.status, data: decode(cached2.body, accept), fromCache: true };
+    }
+  }
+  const limiter = limiterFor(host);
+  let lastErr;
+  for (let attempt2 = 0; attempt2 <= retries; attempt2++) {
+    await limiter.acquire();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetchImpl(url, { method, headers, body, signal: controller.signal });
+      const text2 = await res.text();
+      if (res.ok) {
+        if (ttlMs > 0) await writeCache(key, { fetchedAt: Date.now(), status: res.status, body: text2 });
+        return { status: res.status, data: decode(text2, accept), fromCache: false };
+      }
+      if (RETRYABLE.has(res.status) && attempt2 < retries) {
+        const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
+        await delay(retryAfter ?? backoff(attempt2));
+        lastErr = new HttpError(`HTTP ${res.status} for ${url}`, res.status, url);
+        continue;
+      }
+      throw new HttpError(`HTTP ${res.status} for ${url}`, res.status, url);
+    } catch (err) {
+      lastErr = err;
+      const isAbort = err instanceof Error && err.name === "AbortError";
+      const isHttp = err instanceof HttpError;
+      if (isHttp && !RETRYABLE.has(err.status)) throw err;
+      if (attempt2 < retries) {
+        await delay(backoff(attempt2));
+        continue;
+      }
+      if (isAbort) throw new HttpError(`Timeout after ${timeoutMs}ms for ${url}`, 0, url);
+    } finally {
+      clearTimeout(timer);
+      limiter.release();
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new HttpError(`Request failed for ${url}`, 0, url);
+}
+async function httpGetJson(url, opts) {
+  return httpRequest(url, { ...opts, method: "GET", accept: "json" });
+}
+function decode(text2, accept) {
+  if (accept === "text") return text2;
+  return text2 ? JSON.parse(text2) : null;
+}
+function backoff(attempt2) {
+  const base = 500 * 2 ** attempt2;
+  return base + Math.floor(attempt2 * 137 % 100 * 3);
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (!Number.isNaN(seconds)) return seconds * 1e3;
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var HttpError, DEFAULT_HOST_CONFIG, HOST_CONFIG, HostLimiter, limiters, memoryCache, bypassCacheRead, RETRYABLE;
+var init_http = __esm({
+  "src/core/http.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    HttpError = class extends Error {
+      constructor(message, status, url) {
+        super(message);
+        this.status = status;
+        this.url = url;
+        this.name = "HttpError";
+      }
+      status;
+      url;
+    };
+    DEFAULT_HOST_CONFIG = { maxConcurrent: 6, minIntervalMs: 0 };
+    HOST_CONFIG = {
+      "api.github.com": { maxConcurrent: 4, minIntervalMs: 50 },
+      "registry.npmjs.org": { maxConcurrent: 4, minIntervalMs: 50 },
+      // The downloads API rate-limits aggressively — serialize with a steady gap.
+      // Weekly downloads go through the bulk endpoint; only growth hits this often.
+      "api.npmjs.org": { maxConcurrent: 1, minIntervalMs: 250 },
+      "api.deps.dev": { maxConcurrent: 4, minIntervalMs: 40 },
+      "raw.githubusercontent.com": { maxConcurrent: 4, minIntervalMs: 30 },
+      // Bundlephobia is slow/flaky — be gentle (§9.5).
+      "bundlephobia.com": { maxConcurrent: 2, minIntervalMs: 200 }
+    };
+    HostLimiter = class {
+      constructor(config) {
+        this.config = config;
+      }
+      config;
+      active = 0;
+      nextAvailable = 0;
+      queue = [];
+      async acquire() {
+        if (this.active >= this.config.maxConcurrent) {
+          await new Promise((resolve) => this.queue.push(resolve));
+        }
+        this.active++;
+        const now = Date.now();
+        const wait = Math.max(0, this.nextAvailable - now);
+        this.nextAvailable = Math.max(now, this.nextAvailable) + this.config.minIntervalMs;
+        if (wait > 0) await delay(wait);
+      }
+      release() {
+        this.active--;
+        const next = this.queue.shift();
+        if (next) next();
+      }
+    };
+    limiters = /* @__PURE__ */ new Map();
+    memoryCache = /* @__PURE__ */ new Map();
+    bypassCacheRead = false;
+    RETRYABLE = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+  }
+});
+
+// src/ingestion/sources/npmRegistry.ts
+function encodeNpmName(name) {
+  return name.startsWith("@") ? name.replace("/", "%2F") : name;
+}
+function parseGithubRepo(url) {
+  if (!url) return null;
+  const match = url.match(/github\.com[/:]([^/]+)\/([^/#?]+?)(?:\.git)?(?:[/#?].*)?$/i);
+  if (!match) return null;
+  const owner = match[1];
+  const repo = match[2];
+  if (!owner || !repo) return null;
+  return { owner, repo };
+}
+function normalizeRepoUrl(repository, homepage) {
+  let raw = null;
+  if (typeof repository === "string") raw = repository;
+  else if (repository && typeof repository === "object" && "url" in repository) {
+    raw = String(repository.url);
+  }
+  const repo = parseGithubRepo(raw) ?? parseGithubRepo(homepage);
+  const repoUrl = repo ? `https://github.com/${repo.owner}/${repo.repo}` : cleanUrl(raw) ?? null;
+  return { repoUrl, repo };
+}
+function cleanUrl(url) {
+  if (!url) return null;
+  return url.replace(/^git\+/, "").replace(/^git:\/\//, "https://").replace(/\.git$/, "");
+}
+function pickLicense(value) {
+  if (!value) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && "type" in value) return String(value.type);
+  return null;
+}
+function toDate(value) {
+  if (typeof value !== "string") return null;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? null : new Date(ms);
+}
+function parseNpmRegistry(json2) {
+  const latest = json2?.["dist-tags"]?.latest ?? null;
+  const latestManifest = latest ? json2?.versions?.[latest] ?? {} : {};
+  const time = json2?.time ?? {};
+  const repository = json2?.repository ?? latestManifest?.repository;
+  const homepage = json2?.homepage ?? latestManifest?.homepage ?? null;
+  const { repoUrl, repo } = normalizeRepoUrl(repository, homepage);
+  const deprecated = Boolean(latestManifest?.deprecated ?? json2?.deprecated);
+  const maintainers = Array.isArray(json2?.maintainers) ? json2.maintainers.length : null;
+  return {
+    name: json2?.name ?? "",
+    description: json2?.description ?? latestManifest?.description ?? null,
+    latestVersion: latest,
+    license: pickLicense(json2?.license ?? latestManifest?.license),
+    homepage,
+    repo,
+    repoUrl,
+    firstPublishedAt: toDate(time?.created),
+    lastReleaseAt: toDate(latest ? time?.[latest] : null) ?? toDate(time?.modified),
+    deprecated,
+    maintainersCount: maintainers,
+    readme: typeof json2?.readme === "string" ? json2.readme : null
+  };
+}
+async function fetchNpmRegistry(name, fetchImpl) {
+  const url = `https://${HOST}/${encodeNpmName(name)}`;
+  const { data } = await httpGetJson(url, {
+    host: HOST,
+    ttlMs: CACHE_TTL.npmRegistry,
+    fetchImpl
+  });
+  return parseNpmRegistry(data);
+}
+async function npmPackageExists(name, fetchImpl) {
+  const url = `https://${HOST}/${encodeNpmName(name)}`;
+  try {
+    const { status } = await httpGetJson(url, {
+      host: HOST,
+      ttlMs: 0,
+      retries: 1,
+      fetchImpl
+    });
+    return status === 200;
+  } catch (err) {
+    if (err && typeof err === "object" && "status" in err && err.status === 404) {
+      return false;
+    }
+    throw err;
+  }
+}
+var HOST;
+var init_npmRegistry = __esm({
+  "src/ingestion/sources/npmRegistry.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_http();
+    HOST = "registry.npmjs.org";
+  }
+});
+
+// src/ingestion/sources/npmDownloads.ts
+function parseWeeklyDownloads(json2) {
+  const value = json2?.downloads;
+  return typeof value === "number" ? value : null;
+}
+function parseDownloadGrowth(json2) {
+  const points = Array.isArray(json2?.downloads) ? json2.downloads : [];
+  if (points.length < 60) return null;
+  const tail = points.slice(-60);
+  const prior = tail.slice(0, 30);
+  const recent = tail.slice(30);
+  const sum = (arr) => arr.reduce((acc, p) => acc + (p.downloads || 0), 0);
+  const priorAvg = sum(prior) / prior.length;
+  const recentAvg = sum(recent) / recent.length;
+  if (priorAvg <= 0) return recentAvg > 0 ? 1 : 0;
+  return (recentAvg - priorAvg) / priorAvg;
+}
+function ymd(date) {
+  return date.toISOString().slice(0, 10);
+}
+function last90DayRange(now = /* @__PURE__ */ new Date()) {
+  const end = now;
+  const start = new Date(end.getTime() - 90 * 24 * 60 * 60 * 1e3);
+  return `${ymd(start)}:${ymd(end)}`;
+}
+function parseBulkWeekly(json2, requested) {
+  const map = /* @__PURE__ */ new Map();
+  if (json2 && typeof json2.downloads === "number" && typeof json2.package === "string") {
+    map.set(json2.package, json2.downloads);
+    return map;
+  }
+  for (const name of requested) {
+    const entry = json2?.[name];
+    map.set(name, entry && typeof entry.downloads === "number" ? entry.downloads : null);
+  }
+  return map;
+}
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+async function fetchWeeklyDownloads(name, fetchImpl) {
+  try {
+    const { data } = await httpGetJson(
+      `https://${HOST2}/downloads/point/last-week/${name}`,
+      { host: HOST2, ttlMs: CACHE_TTL.npmDownloads, retries: 5, fetchImpl }
+    );
+    return parseWeeklyDownloads(data);
+  } catch (err) {
+    if (err instanceof HttpError && err.status === 404) return null;
+    throw err;
+  }
+}
+async function fetchDownloadGrowth(name, fetchImpl) {
+  try {
+    const { data } = await httpGetJson(
+      `https://${HOST2}/downloads/range/${last90DayRange()}/${name}`,
+      { host: HOST2, ttlMs: CACHE_TTL.npmDownloads, retries: 3, fetchImpl }
+    );
+    return parseDownloadGrowth(data);
+  } catch {
+    return null;
+  }
+}
+async function fetchBulkWeeklyDownloads(names, fetchImpl) {
+  const result = /* @__PURE__ */ new Map();
+  const unscoped = names.filter((n) => !n.startsWith("@"));
+  const scoped = names.filter((n) => n.startsWith("@"));
+  for (const batch of chunk(unscoped, BULK_CHUNK)) {
+    try {
+      const { data } = await httpGetJson(
+        `https://${HOST2}/downloads/point/last-week/${batch.join(",")}`,
+        { host: HOST2, ttlMs: CACHE_TTL.npmDownloads, retries: 5, fetchImpl }
+      );
+      for (const [k, v] of parseBulkWeekly(data, batch)) result.set(k, v);
+    } catch {
+    }
+  }
+  for (const name of scoped) {
+    try {
+      result.set(name, await fetchWeeklyDownloads(name, fetchImpl));
+    } catch {
+    }
+  }
+  return result;
+}
+var HOST2, BULK_CHUNK;
+var init_npmDownloads = __esm({
+  "src/ingestion/sources/npmDownloads.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_http();
+    HOST2 = "api.npmjs.org";
+    BULK_CHUNK = 128;
+  }
+});
+
+// src/ingestion/sources/github.ts
+function parseGithub(json2, now = /* @__PURE__ */ new Date()) {
+  const repo = json2?.data?.repository;
+  if (!repo) return null;
+  const releaseNodes = repo.releases?.nodes ?? [];
+  const releaseDates = releaseNodes.map((n) => Date.parse(n.createdAt)).filter((ms) => !Number.isNaN(ms));
+  const cutoff = now.getTime() - ONE_YEAR_MS;
+  return {
+    stars: typeof repo.stargazerCount === "number" ? repo.stargazerCount : null,
+    openIssues: repo.openIssues?.totalCount ?? null,
+    closedIssues: repo.closedIssues?.totalCount ?? null,
+    archived: Boolean(repo.isArchived),
+    lastReleaseAt: releaseDates.length ? new Date(Math.max(...releaseDates)) : null,
+    releasesLast12mo: releaseDates.filter((ms) => ms >= cutoff).length
+  };
+}
+async function fetchGithubRepo(owner, repo, token, fetchImpl) {
+  const body = JSON.stringify({ query: QUERY, variables: { owner, name: repo } });
+  const { data } = await httpRequest(ENDPOINT, {
+    host: HOST3,
+    ttlMs: CACHE_TTL.github,
+    method: "POST",
+    headers: {
+      Authorization: `bearer ${token}`,
+      "Content-Type": "application/json",
+      "User-Agent": "lurq"
+    },
+    body,
+    // Keep the auth token out of the cache key.
+    cacheKey: `POST ${ENDPOINT} ${owner}/${repo}`,
+    fetchImpl
+  });
+  return parseGithub(data);
+}
+var HOST3, ENDPOINT, QUERY, ONE_YEAR_MS;
+var init_github = __esm({
+  "src/ingestion/sources/github.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_http();
+    HOST3 = "api.github.com";
+    ENDPOINT = `https://${HOST3}/graphql`;
+    QUERY = `query($owner:String!, $name:String!) {
+  repository(owner:$owner, name:$name) {
+    stargazerCount
+    isArchived
+    openIssues: issues(states:OPEN) { totalCount }
+    closedIssues: issues(states:CLOSED) { totalCount }
+    releases(first: 50, orderBy: {field: CREATED_AT, direction: DESC}) {
+      nodes { createdAt }
+    }
+  }
+}`;
+    ONE_YEAR_MS = 365 * 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/ingestion/sources/depsDev.ts
+function encodeName(name) {
+  return encodeURIComponent(name);
+}
+function severityFromCvss(score) {
+  if (score == null) return "moderate";
+  if (score >= 9) return "critical";
+  if (score >= 7) return "high";
+  if (score >= 4) return "moderate";
+  if (score > 0) return "low";
+  return "info";
+}
+function parseScorecard(json2) {
+  const score = json2?.scorecard?.overallScore;
+  return typeof score === "number" ? score : null;
+}
+function parseAdvisoryKeys(versionJson) {
+  const keys = versionJson?.advisoryKeys;
+  if (!Array.isArray(keys)) return [];
+  return keys.map((k) => typeof k === "string" ? k : k?.id).filter((id) => typeof id === "string");
+}
+function parseAdvisoryDetail(json2) {
+  return {
+    id: json2?.advisoryKey?.id ?? json2?.advisoryKey ?? "unknown",
+    severity: severityFromCvss(json2?.cvss3Score),
+    summary: json2?.title ?? ""
+  };
+}
+async function fetchScorecard(owner, repo, fetchImpl) {
+  const projectKey = encodeURIComponent(`github.com/${owner}/${repo}`);
+  const url = `https://${HOST4}/v3/projects/${projectKey}`;
+  try {
+    const { data } = await httpGetJson(url, {
+      host: HOST4,
+      ttlMs: CACHE_TTL.depsDev,
+      fetchImpl
+    });
+    return parseScorecard(data);
+  } catch {
+    return null;
+  }
+}
+async function fetchAdvisories(name, version, fetchImpl) {
+  const versionUrl = `https://${HOST4}/v3/systems/npm/packages/${encodeName(name)}/versions/${encodeURIComponent(version)}`;
+  let keys = [];
+  try {
+    const { data } = await httpGetJson(versionUrl, {
+      host: HOST4,
+      ttlMs: CACHE_TTL.depsDev,
+      fetchImpl
+    });
+    keys = parseAdvisoryKeys(data).slice(0, MAX_ADVISORIES);
+  } catch {
+    return [];
+  }
+  const details = await Promise.allSettled(
+    keys.map(
+      (key) => httpGetJson(`https://${HOST4}/v3/advisories/${encodeURIComponent(key)}`, {
+        host: HOST4,
+        ttlMs: CACHE_TTL.depsDev,
+        fetchImpl
+      })
+    )
+  );
+  return details.filter(
+    (d) => d.status === "fulfilled"
+  ).map((d) => parseAdvisoryDetail(d.value.data));
+}
+async function fetchDepsDev(name, version, repo, fetchImpl) {
+  const [scorecard, advisories] = await Promise.all([
+    repo ? fetchScorecard(repo.owner, repo.repo, fetchImpl) : Promise.resolve(null),
+    version ? fetchAdvisories(name, version, fetchImpl) : Promise.resolve([])
+  ]);
+  return { scorecard, advisories };
+}
+var HOST4, MAX_ADVISORIES;
+var init_depsDev = __esm({
+  "src/ingestion/sources/depsDev.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_http();
+    HOST4 = "api.deps.dev";
+    MAX_ADVISORIES = 10;
+  }
+});
+
+// src/ingestion/sources/bundlephobia.ts
+function parseBundleSize(json2) {
+  const gzipBytes = json2?.gzip;
+  if (typeof gzipBytes !== "number") return null;
+  return Math.round(gzipBytes / 1024 * 10) / 10;
+}
+async function fetchBundlephobia(name, category, fetchImpl) {
+  if (!isFrontendCategory(category)) return { bundleMinGzipKb: null };
+  const url = `https://${HOST5}/api/size?package=${encodeURIComponent(name)}`;
+  try {
+    const { data } = await httpGetJson(url, {
+      host: HOST5,
+      ttlMs: CACHE_TTL.bundlephobia,
+      timeoutMs: 12e3,
+      retries: 1,
+      fetchImpl
+    });
+    return { bundleMinGzipKb: parseBundleSize(data) };
+  } catch {
+    return { bundleMinGzipKb: null };
+  }
+}
+var HOST5;
+var init_bundlephobia = __esm({
+  "src/ingestion/sources/bundlephobia.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_http();
+    init_types();
+    HOST5 = "bundlephobia.com";
+  }
+});
+
+// src/ingestion/sources/index.ts
+var init_sources = __esm({
+  "src/ingestion/sources/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_npmRegistry();
+    init_npmDownloads();
+    init_github();
+    init_depsDev();
+    init_bundlephobia();
+  }
+});
+
+// src/ingestion/sources/githubReadme.ts
+async function fetchGithubReadme(owner, repo, fetchImpl) {
+  for (const file of CANDIDATES) {
+    const url = `https://${HOST6}/${owner}/${repo}/HEAD/${file}`;
+    try {
+      const { data } = await httpRequest(url, {
+        host: HOST6,
+        ttlMs: CACHE_TTL.github,
+        accept: "text",
+        retries: 0,
+        fetchImpl
+      });
+      if (data && data.trim().length > 0) return data;
+    } catch {
+    }
+  }
+  return null;
+}
+var HOST6, CANDIDATES;
+var init_githubReadme = __esm({
+  "src/ingestion/sources/githubReadme.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_http();
+    HOST6 = "raw.githubusercontent.com";
+    CANDIDATES = ["README.md", "readme.md", "README.markdown", "README"];
+  }
+});
+
+// src/ingestion/summarize.ts
+function context7Hint(name) {
+  return `For the exact current API of "${name}", resolve it via Context7 (resolve-library-id \u2192 query-docs).`;
+}
+function truncateSentences(text2, max = 3) {
+  const clean = text2.replace(/\s+/g, " ").trim();
+  if (!clean) return "";
+  const sentences = clean.match(/[^.!?]+[.!?]+|[^.!?]+$/g) ?? [clean];
+  return sentences.slice(0, max).map((s) => s.trim()).join(" ").trim();
+}
+function buildUserPrompt(input) {
+  const readme = (input.readme ?? "").slice(0, 4e3);
+  return [
+    `Package: ${input.name}`,
+    `Category: ${input.category ?? "unknown"}`,
+    `Description: ${input.description ?? "(none)"}`,
+    `README (truncated):
+${readme || "(none)"}`,
+    "",
+    "Return JSON with keys:",
+    '- "summary": 2-3 sentences: what it is, when to use it, how it fits an app.',
+    '- "whatItIs": one sentence.',
+    '- "whenToUse": one sentence on the ideal use case.',
+    '- "whenNotToUse": one sentence on when to pick something else (or "").',
+    '- "whereItFits": one sentence on its architectural role.',
+    '- "howToWireIn": one short sentence on the minimal setup (install + entry point), or "".'
+  ].join("\n");
+}
+function str(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function createSummaryProvider(fetchImpl) {
+  const config = getConfig();
+  if (config.SUMMARY_PROVIDER === "openai" && config.SUMMARY_API_KEY) {
+    return new OpenAISummaryProvider(config.SUMMARY_API_KEY, config.SUMMARY_MODEL, fetchImpl);
+  }
+  return new FallbackSummaryProvider();
+}
+async function buildSummaryInput(signals, category, fetchImpl) {
+  const registry = signals.registry;
+  let readme = registry?.readme?.trim() || null;
+  if (!readme && registry?.repo) {
+    readme = await fetchGithubReadme(registry.repo.owner, registry.repo.repo, fetchImpl).catch(
+      () => null
+    );
+  }
+  return {
+    name: signals.name,
+    description: registry?.description ?? null,
+    category,
+    readme,
+    repoUrl: registry?.repoUrl ?? null
+  };
+}
+var CATEGORY_ROLE, FallbackSummaryProvider, SYSTEM_PROMPT, OpenAISummaryProvider;
+var init_summarize = __esm({
+  "src/ingestion/summarize.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_http();
+    init_logger();
+    init_githubReadme();
+    CATEGORY_ROLE = {
+      framework: "the core application framework your app is built on",
+      "meta-framework": "the full-stack framework wrapping routing, rendering, and build",
+      "state-management": "the client state layer shared across components",
+      routing: "the routing layer mapping URLs to views",
+      orm: "the data-access layer between your code and the database",
+      "database-client": "the low-level driver that talks to your database",
+      "ui-component-library": "the prebuilt UI component layer",
+      styling: "the styling layer for your components",
+      forms: "form state and submission handling",
+      validation: "input/schema validation at your boundaries",
+      "data-fetching": "the server-state/data-fetching layer",
+      "http-client": "the HTTP request layer for calling APIs",
+      auth: "authentication and session handling",
+      testing: "the test tooling layer",
+      "build-tool": "the build/dev pipeline",
+      bundler: "the module bundling step",
+      linting: "code-quality and formatting checks",
+      "date-time": "date and time handling",
+      animation: "UI animation and motion",
+      charts: "data visualization and charts",
+      i18n: "internationalization and localization",
+      utility: "a focused helper you compose into your app",
+      other: "a supporting library in your app"
+    };
+    FallbackSummaryProvider = class {
+      kind = "fallback";
+      async generate(input) {
+        const description = input.description?.trim() || null;
+        const role = CATEGORY_ROLE[input.category ?? "other"] ?? CATEGORY_ROLE.other;
+        const summary = description ? truncateSentences(description, 3) : null;
+        const guide = {
+          whatItIs: description ? truncateSentences(description, 2) : input.name,
+          whenToUse: `Reach for ${input.name} when you need ${role}.`,
+          whereItFits: `Sits at ${role}.`,
+          context7Hint: context7Hint(input.name)
+        };
+        return { summary, usageGuide: guide };
+      }
+    };
+    SYSTEM_PROMPT = "You summarize npm packages factually for an AI coding agent choosing dependencies. Use ONLY the provided README/description. Never invent capabilities or APIs. Be concise and concrete. Respond with a JSON object.";
+    OpenAISummaryProvider = class {
+      constructor(apiKey, model, fetchImpl) {
+        this.apiKey = apiKey;
+        this.model = model;
+        this.fetchImpl = fetchImpl;
+      }
+      apiKey;
+      model;
+      fetchImpl;
+      kind = "openai";
+      async generate(input) {
+        try {
+          const body = JSON.stringify({
+            model: this.model,
+            messages: [
+              { role: "system", content: SYSTEM_PROMPT },
+              { role: "user", content: buildUserPrompt(input) }
+            ],
+            response_format: { type: "json_object" },
+            temperature: 0.2
+          });
+          const { data } = await httpRequest("https://api.openai.com/v1/chat/completions", {
+            host: "api.openai.com",
+            method: "POST",
+            ttlMs: 30 * 24 * 60 * 60 * 1e3,
+            // cache summaries 30d to control cost
+            cacheKey: `openai-summary ${this.model} ${input.name} ${(input.readme ?? "").length}`,
+            headers: {
+              Authorization: `Bearer ${this.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body,
+            fetchImpl: this.fetchImpl
+          });
+          const content = data?.choices?.[0]?.message?.content;
+          const parsed = content ? JSON.parse(content) : {};
+          const guide = {
+            whatItIs: str(parsed.whatItIs) || input.name,
+            whenToUse: str(parsed.whenToUse),
+            whenNotToUse: str(parsed.whenNotToUse) || void 0,
+            whereItFits: str(parsed.whereItFits),
+            howToWireIn: str(parsed.howToWireIn) || void 0,
+            context7Hint: context7Hint(input.name)
+          };
+          return { summary: str(parsed.summary) ? truncateSentences(parsed.summary, 3) : null, usageGuide: guide };
+        } catch (err) {
+          logger.warn(`summary LLM failed for ${input.name}, using fallback: ${err.message}`);
+          return new FallbackSummaryProvider().generate(input);
+        }
+      }
+    };
+  }
+});
+
+// src/ingestion/collect.ts
+async function attempt(source, errors, fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    errors.push({ source, message });
+    logger.debug(`[${source}] ${message}`);
+    return null;
+  }
+}
+async function collectSignals(name, category, deps = {}) {
+  const { githubToken, fetchImpl } = deps;
+  const errors = [];
+  const registry = await attempt("npm-registry", errors, () => fetchNpmRegistry(name, fetchImpl));
+  const repo = registry?.repo ?? null;
+  const version = registry?.latestVersion ?? null;
+  const [downloads, github, depsDev, bundle] = await Promise.all([
+    attempt("npm-downloads", errors, async () => {
+      const weeklyDownloads = deps.prefetchedWeekly !== void 0 ? deps.prefetchedWeekly : await fetchWeeklyDownloads(name, fetchImpl);
+      const downloadGrowth90d = await fetchDownloadGrowth(name, fetchImpl);
+      return { weeklyDownloads, downloadGrowth90d };
+    }),
+    repo && githubToken ? attempt("github", errors, () => fetchGithubRepo(repo.owner, repo.repo, githubToken, fetchImpl)) : Promise.resolve(null),
+    attempt("deps-dev", errors, () => fetchDepsDev(name, version, repo, fetchImpl)),
+    attempt("bundlephobia", errors, () => fetchBundlephobia(name, category, fetchImpl))
+  ]);
+  return { name, registry, downloads, github, depsDev, bundle, errors };
+}
+var init_collect = __esm({
+  "src/ingestion/collect.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_bundlephobia();
+    init_depsDev();
+    init_github();
+    init_npmDownloads();
+    init_npmRegistry();
+  }
+});
+
+// src/scoring/weights.ts
+var HEALTH_WEIGHTS, MAINTENANCE_WEIGHTS, MAINTENANCE, ADOPTION, RELIABILITY, EFFICIENCY, CONFIDENCE;
+var init_weights = __esm({
+  "src/scoring/weights.ts"() {
+    "use strict";
+    init_esm_shims();
+    HEALTH_WEIGHTS = {
+      maintenance: 0.35,
+      adoption: 0.3,
+      reliability: 0.25,
+      efficiency: 0.1
+    };
+    MAINTENANCE_WEIGHTS = {
+      recency: 0.5,
+      cadence: 0.25,
+      closeRatio: 0.25
+    };
+    MAINTENANCE = {
+      /** A release within this many days scores full recency. */
+      freshDays: 30,
+      /** Recency decays linearly to 0 by this many days (~24 months). */
+      staleDays: 730,
+      /** Releases/12mo at or above this cap full cadence. */
+      cadenceCap: 12,
+      /** deprecated/archived hard-cap maintenance at this value. */
+      deadCap: 15
+    };
+    ADOPTION = {
+      /** log10(weekly downloads): this maps to 0. */
+      downloadsLogMin: 1,
+      // 10/wk
+      /** log10(weekly downloads): this maps to 100. */
+      downloadsLogMax: 7,
+      // 10M/wk
+      /** log10(stars) that maps to 100. */
+      starsLogMax: 5,
+      // 100k stars
+      /** Weight of the stars component when available (downloads gets the rest). */
+      starsWeight: 0.2,
+      /** Growth bonus: growth fraction × this, clamped to ±cap. */
+      growthMultiplier: 30,
+      growthBonusCap: 20
+    };
+    RELIABILITY = {
+      /** Used when no Scorecard is available (unknown security posture). */
+      neutralWhenUnknown: 50,
+      /** Advisory penalties by severity. */
+      penalty: {
+        critical: 40,
+        high: 20,
+        moderate: 8,
+        low: 3,
+        info: 0
+      }
+    };
+    EFFICIENCY = {
+      /** Bundle size at the category median maps to this score; smaller → higher. */
+      medianScore: 50
+    };
+    CONFIDENCE = {
+      proven: {
+        minWeeklyDownloads: 1e5,
+        minAgeMonths: 12,
+        maxLastReleaseMonths: 6
+      },
+      emerging: {
+        minWeeklyDownloads: 5e3,
+        strongGrowth: 0.5,
+        maxLastReleaseMonths: 9
+      }
+    };
+  }
+});
+
+// src/scoring/score.ts
+function toScoringInput(signals, category) {
+  const { registry, downloads, github, depsDev, bundle } = signals;
+  return {
+    weeklyDownloads: downloads?.weeklyDownloads ?? null,
+    downloadGrowth90d: downloads?.downloadGrowth90d ?? null,
+    stars: github?.stars ?? null,
+    dependentsCount: null,
+    // not collected in v1 (see spec R1 note)
+    firstPublishedAt: registry?.firstPublishedAt ?? null,
+    lastReleaseAt: github?.lastReleaseAt ?? registry?.lastReleaseAt ?? null,
+    releasesLast12mo: github?.releasesLast12mo ?? null,
+    openIssues: github?.openIssues ?? null,
+    closedIssues: github?.closedIssues ?? null,
+    scorecard: depsDev?.scorecard ?? null,
+    advisories: depsDev?.advisories ?? [],
+    deprecated: registry?.deprecated ?? false,
+    archived: github?.archived ?? false,
+    bundleMinGzipKb: bundle?.bundleMinGzipKb ?? null,
+    category
+  };
+}
+function computeMaintenance(input, now) {
+  if (input.deprecated || input.archived) return MAINTENANCE.deadCap;
+  const components = [];
+  const days = daysSince(input.lastReleaseAt, now);
+  if (days !== null) {
+    const recency = days <= MAINTENANCE.freshDays ? 100 : clamp(100 * (MAINTENANCE.staleDays - days) / (MAINTENANCE.staleDays - MAINTENANCE.freshDays));
+    components.push({ value: recency, weight: MAINTENANCE_WEIGHTS.recency });
+  }
+  if (input.releasesLast12mo !== null) {
+    const cadence = clamp(Math.min(input.releasesLast12mo, MAINTENANCE.cadenceCap) / MAINTENANCE.cadenceCap * 100);
+    components.push({ value: cadence, weight: MAINTENANCE_WEIGHTS.cadence });
+  }
+  if (input.openIssues !== null && input.closedIssues !== null) {
+    const total = input.openIssues + input.closedIssues;
+    if (total > 0) {
+      components.push({ value: input.closedIssues / total * 100, weight: MAINTENANCE_WEIGHTS.closeRatio });
+    }
+  }
+  return weightedAverage(components);
+}
+function computeAdoption(input) {
+  const dl = input.weeklyDownloads ?? 0;
+  const downloadsScore = clamp(
+    (Math.log10(Math.max(dl, 1)) - ADOPTION.downloadsLogMin) / (ADOPTION.downloadsLogMax - ADOPTION.downloadsLogMin) * 100
+  );
+  let base = downloadsScore;
+  if (input.stars !== null) {
+    const starsScore = clamp(Math.log10(Math.max(input.stars, 1)) / ADOPTION.starsLogMax * 100);
+    base = (1 - ADOPTION.starsWeight) * downloadsScore + ADOPTION.starsWeight * starsScore;
+  }
+  if (input.downloadGrowth90d !== null) {
+    const bonus = clamp(
+      input.downloadGrowth90d * ADOPTION.growthMultiplier,
+      -ADOPTION.growthBonusCap,
+      ADOPTION.growthBonusCap
+    );
+    base += bonus;
+  }
+  return clamp(base);
+}
+function computeReliability(input) {
+  const base = input.scorecard !== null ? input.scorecard * 10 : RELIABILITY.neutralWhenUnknown;
+  const penalty = input.advisories.reduce(
+    (sum, adv) => sum + (RELIABILITY.penalty[adv.severity] ?? 0),
+    0
+  );
+  return clamp(base - penalty);
+}
+function computeEfficiency(bundleMinGzipKb, category, categoryMedian) {
+  if (!isFrontendCategory(category) || bundleMinGzipKb === null || !categoryMedian || categoryMedian <= 0) {
+    return null;
+  }
+  const ratio = bundleMinGzipKb / categoryMedian;
+  return clamp(100 - ratio * EFFICIENCY.medianScore);
+}
+function computeHealthScore(breakdown) {
+  const { maintenance, adoption, reliability, efficiency } = breakdown;
+  if (efficiency === null) {
+    const w = HEALTH_WEIGHTS;
+    const denom = w.maintenance + w.adoption + w.reliability;
+    return Math.round(
+      (w.maintenance * maintenance + w.adoption * adoption + w.reliability * reliability) / denom
+    );
+  }
+  return Math.round(
+    HEALTH_WEIGHTS.maintenance * maintenance + HEALTH_WEIGHTS.adoption * adoption + HEALTH_WEIGHTS.reliability * reliability + HEALTH_WEIGHTS.efficiency * efficiency
+  );
+}
+function hasCriticalOrHighAdvisory(advisories) {
+  return advisories.some((a) => a.severity === "critical" || a.severity === "high");
+}
+function computeConfidence(input, now) {
+  const dl = input.weeklyDownloads ?? 0;
+  const ageMonths = monthsSince(input.firstPublishedAt, now);
+  const lastReleaseMonths = monthsSince(input.lastReleaseAt, now);
+  const growth = input.downloadGrowth90d ?? 0;
+  const provenReleaseOk = lastReleaseMonths !== null && lastReleaseMonths <= CONFIDENCE.proven.maxLastReleaseMonths;
+  const provenAgeOk = ageMonths !== null && ageMonths >= CONFIDENCE.proven.minAgeMonths;
+  if (dl >= CONFIDENCE.proven.minWeeklyDownloads && provenAgeOk && provenReleaseOk && !hasCriticalOrHighAdvisory(input.advisories) && !input.deprecated && !input.archived) {
+    return "proven";
+  }
+  const emergingReleaseOk = lastReleaseMonths !== null && lastReleaseMonths <= CONFIDENCE.emerging.maxLastReleaseMonths;
+  const emergingAdoptionOk = dl >= CONFIDENCE.emerging.minWeeklyDownloads || growth >= CONFIDENCE.emerging.strongGrowth;
+  if (emergingAdoptionOk && emergingReleaseOk && !input.deprecated && !input.archived) {
+    return "emerging";
+  }
+  return "unproven";
+}
+function weightedAverage(components) {
+  if (components.length === 0) return 0;
+  const totalWeight = components.reduce((s, c) => s + c.weight, 0);
+  if (totalWeight === 0) return 0;
+  return Math.round(components.reduce((s, c) => s + c.value * c.weight, 0) / totalWeight);
+}
+function median(values) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+var DAY_MS, MONTH_MS, clamp, daysSince, monthsSince;
+var init_score = __esm({
+  "src/scoring/score.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_types();
+    init_weights();
+    DAY_MS = 24 * 60 * 60 * 1e3;
+    MONTH_MS = 30 * DAY_MS;
+    clamp = (n, lo = 0, hi = 100) => Math.max(lo, Math.min(hi, n));
+    daysSince = (date, now) => date ? (now.getTime() - date.getTime()) / DAY_MS : null;
+    monthsSince = (date, now) => date ? (now.getTime() - date.getTime()) / MONTH_MS : null;
+  }
+});
+
+// src/scoring/index.ts
+var init_scoring = __esm({
+  "src/scoring/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_score();
+    init_weights();
+  }
+});
+
+// src/search/embeddings.ts
+import { createHash as createHash2 } from "crypto";
+function buildEmbeddingText(input) {
+  const body = input.summary || input.description || "";
+  return `${input.name}. ${input.category ?? ""}. ${body}`.trim();
+}
+function tokenize(text2) {
+  return text2.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1);
+}
+function fnv1a(str2) {
+  let h = 2166136261;
+  for (let i = 0; i < str2.length; i++) {
+    h ^= str2.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function localEmbed(text2, dim2 = EMBEDDING_DIM) {
+  const vec = new Float64Array(dim2);
+  const tokens = tokenize(text2);
+  const add = (token, weight) => {
+    const idx = fnv1a(token) % dim2;
+    const sign = fnv1a("s:" + token) & 1 ? 1 : -1;
+    vec[idx] += weight * sign;
+  };
+  for (const t of tokens) add(t, 1);
+  for (let i = 0; i < tokens.length - 1; i++) add(`${tokens[i]} ${tokens[i + 1]}`, 0.5);
+  let norm = 0;
+  for (let i = 0; i < dim2; i++) norm += vec[i] * vec[i];
+  norm = Math.sqrt(norm) || 1;
+  const out = new Array(dim2);
+  for (let i = 0; i < dim2; i++) out[i] = vec[i] / norm;
+  return out;
+}
+function createEmbeddingProvider(fetchImpl) {
+  const config = getConfig();
+  if (config.EMBEDDING_PROVIDER === "openai" && config.EMBEDDING_API_KEY) {
+    return new OpenAIEmbeddingProvider(config.EMBEDDING_API_KEY, config.EMBEDDING_MODEL, fetchImpl);
+  }
+  if (config.EMBEDDING_PROVIDER === "openai" && !config.EMBEDDING_API_KEY) {
+    logger.warn("EMBEDDING_API_KEY not set \u2014 falling back to the local embedder.");
+  }
+  return new LocalEmbeddingProvider();
+}
+var LocalEmbeddingProvider, OPENAI_BATCH, OpenAIEmbeddingProvider;
+var init_embeddings = __esm({
+  "src/search/embeddings.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_constants();
+    init_http();
+    init_logger();
+    LocalEmbeddingProvider = class {
+      kind = "local";
+      dimensions = EMBEDDING_DIM;
+      async embed(texts) {
+        return texts.map((t) => localEmbed(t));
+      }
+    };
+    OPENAI_BATCH = 96;
+    OpenAIEmbeddingProvider = class {
+      constructor(apiKey, model, fetchImpl) {
+        this.apiKey = apiKey;
+        this.model = model;
+        this.fetchImpl = fetchImpl;
+      }
+      apiKey;
+      model;
+      fetchImpl;
+      kind = "openai";
+      dimensions = EMBEDDING_DIM;
+      async embed(texts) {
+        const out = [];
+        for (let i = 0; i < texts.length; i += OPENAI_BATCH) {
+          const batch = texts.slice(i, i + OPENAI_BATCH);
+          const body = JSON.stringify({ model: this.model, input: batch });
+          const { data } = await httpRequest("https://api.openai.com/v1/embeddings", {
+            host: "api.openai.com",
+            method: "POST",
+            ttlMs: 30 * 24 * 60 * 60 * 1e3,
+            // cache embeddings 30d to control cost
+            cacheKey: `openai-embed ${this.model} ${createHash2("sha256").update(body).digest("hex")}`,
+            headers: { Authorization: `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
+            body,
+            fetchImpl: this.fetchImpl
+          });
+          const vectors = data?.data ?? [];
+          vectors.sort((a, b) => a.index - b.index);
+          for (const v of vectors) out.push(v.embedding);
+        }
+        return out;
+      }
+    };
+  }
+});
+
+// src/db/packages.ts
+import { eq, sql } from "drizzle-orm";
+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 getPackageByName(db, name) {
+  const rows = await db.select().from(packages).where(eq(packages.name, name)).limit(1);
+  return rows[0] ?? null;
+}
+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, createdAt: _createdAt, ...mutable } = row;
+  await db.insert(packages).values(row).onConflictDoUpdate({
+    target: packages.name,
+    set: { ...mutable, updatedAt: /* @__PURE__ */ new Date() }
+  });
+}
+async function startSyncRun(db) {
+  const [row] = await db.insert(syncRuns).values({ status: "running" }).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));
+}
+var init_packages = __esm({
+  "src/db/packages.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_schema();
+  }
+});
+
+// src/core/concurrency.ts
+async function pMap(items, mapper, concurrency) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const workerCount = Math.max(1, Math.min(concurrency, items.length));
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (cursor < items.length) {
+      const index2 = cursor++;
+      results[index2] = await mapper(items[index2], index2);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+var init_concurrency = __esm({
+  "src/core/concurrency.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/pipeline/sync.ts
+async function runSync(opts = {}) {
+  const config = getConfig();
+  const now = /* @__PURE__ */ new Date();
+  if (opts.full) setCacheBypassRead(true);
+  const handle = createDb({ max: Math.max(4, config.LURQ_SYNC_CONCURRENCY) });
+  const provider = createSummaryProvider();
+  logger.info(`Summary provider: ${provider.kind}`);
+  const runId = await startSyncRun(handle.db);
+  const allErrors = [];
+  try {
+    const targets = await resolveTargets(handle.db, opts);
+    logger.info(`Syncing ${targets.length} package(s) with concurrency ${config.LURQ_SYNC_CONCURRENCY}\u2026`);
+    logger.info("Fetching weekly downloads in bulk\u2026");
+    const weeklyMap = await fetchBulkWeeklyDownloads(targets.map((t) => t.name));
+    let done = 0;
+    const computed = await pMap(
+      targets,
+      async (target) => {
+        try {
+          const signals = await collectSignals(target.name, target.category, {
+            githubToken: config.GITHUB_TOKEN,
+            prefetchedWeekly: weeklyMap.has(target.name) ? weeklyMap.get(target.name) : void 0
+          });
+          for (const e of signals.errors) allErrors.push({ package: target.name, ...e });
+          const input = toScoringInput(signals, target.category);
+          const summaryInput = await buildSummaryInput(signals, target.category);
+          const { summary, usageGuide } = await provider.generate(summaryInput);
+          if (++done % 25 === 0) logger.info(`  \u2026${done}/${targets.length}`);
+          return {
+            target,
+            signals,
+            input,
+            maintenance: computeMaintenance(input, now),
+            adoption: computeAdoption(input),
+            reliability: computeReliability(input),
+            confidence: computeConfidence(input, now),
+            summary,
+            usageGuide
+          };
+        } catch (err) {
+          allErrors.push({
+            package: target.name,
+            source: "pipeline",
+            message: err instanceof Error ? err.message : String(err)
+          });
+          return null;
+        }
+      },
+      config.LURQ_SYNC_CONCURRENCY
+    );
+    const ok = computed.filter((c) => c !== null);
+    const medians = computeCategoryMedians(ok);
+    const embProvider = createEmbeddingProvider();
+    logger.info(`Embedding provider: ${embProvider.kind}`);
+    const embeddings = await embProvider.embed(
+      ok.map(
+        (c) => buildEmbeddingText({
+          name: c.target.name,
+          category: c.target.category,
+          summary: c.summary,
+          description: c.signals.registry?.description ?? null
+        })
+      )
+    );
+    let updated = 0;
+    for (let i = 0; i < ok.length; i++) {
+      const c = ok[i];
+      const efficiency = computeEfficiency(
+        c.input.bundleMinGzipKb,
+        c.target.category,
+        c.target.category ? medians.get(c.target.category) ?? null : null
+      );
+      const breakdown = {
+        maintenance: c.maintenance,
+        adoption: c.adoption,
+        reliability: c.reliability,
+        efficiency
+      };
+      const healthScore = computeHealthScore(breakdown);
+      await upsertPackage(
+        handle.db,
+        assemblePackageRow({
+          name: c.target.name,
+          category: c.target.category,
+          signals: c.signals,
+          input: c.input,
+          summary: c.summary,
+          usageGuide: c.usageGuide,
+          confidence: c.confidence,
+          breakdown,
+          healthScore,
+          embedding: embeddings[i] ?? null,
+          now
+        })
+      );
+      updated++;
+    }
+    const status = updated === 0 ? "failed" : allErrors.length > 0 ? "partial" : "success";
+    await finishSyncRun(handle.db, runId, {
+      packagesSeen: targets.length,
+      packagesUpdated: updated,
+      errors: allErrors,
+      status
+    });
+    logger.info(`Sync ${status}: ${updated}/${targets.length} updated, ${allErrors.length} source errors.`);
+    return { seen: targets.length, updated, errors: allErrors.length, status };
+  } catch (err) {
+    await finishSyncRun(handle.db, runId, {
+      packagesSeen: 0,
+      packagesUpdated: 0,
+      errors: [{ package: "*", source: "pipeline", message: err.message }],
+      status: "failed"
+    });
+    throw err;
+  } finally {
+    if (opts.full) setCacheBypassRead(false);
+    await handle.close();
+  }
+}
+async function resolveTargets(db, opts) {
+  if (opts.packageName) {
+    const seeds = await getSeedTargets(db);
+    const found = seeds.find((s) => s.name === opts.packageName);
+    return [{ name: opts.packageName, category: found?.category ?? null }];
+  }
+  return getSeedTargets(db);
+}
+function computeCategoryMedians(computed) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const c of computed) {
+    const cat = c.target.category;
+    const kb = c.input.bundleMinGzipKb;
+    if (cat && isFrontendCategory(cat) && kb !== null) {
+      const list = byCategory.get(cat) ?? [];
+      list.push(kb);
+      byCategory.set(cat, list);
+    }
+  }
+  const medians = /* @__PURE__ */ new Map();
+  for (const [cat, list] of byCategory) {
+    const m = median(list);
+    if (m !== null) medians.set(cat, m);
+  }
+  return medians;
+}
+function assemblePackageRow(p) {
+  const r = p.signals.registry;
+  return {
+    name: p.name,
+    ecosystem: "npm",
+    category: p.category,
+    description: r?.description ?? null,
+    summary: p.summary,
+    repoUrl: r?.repoUrl ?? null,
+    homepage: r?.homepage ?? null,
+    latestVersion: r?.latestVersion ?? null,
+    license: r?.license ?? null,
+    deprecated: p.input.deprecated,
+    archived: p.input.archived,
+    firstPublishedAt: p.input.firstPublishedAt,
+    lastReleaseAt: p.input.lastReleaseAt,
+    weeklyDownloads: p.input.weeklyDownloads,
+    downloadGrowth90d: p.input.downloadGrowth90d,
+    dependentsCount: p.input.dependentsCount,
+    stars: p.input.stars,
+    openIssues: p.input.openIssues,
+    closedIssues: p.input.closedIssues,
+    scorecard: p.input.scorecard,
+    bundleMinGzipKb: p.input.bundleMinGzipKb,
+    advisories: p.input.advisories,
+    healthScore: p.healthScore,
+    confidence: p.confidence,
+    scoreBreakdown: p.breakdown,
+    usageGuide: p.usageGuide,
+    embedding: p.embedding,
+    dataAsOf: p.now
+  };
+}
+var init_sync = __esm({
+  "src/pipeline/sync.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_concurrency();
+    init_http();
+    init_logger();
+    init_collect();
+    init_npmDownloads();
+    init_summarize();
+    init_embeddings();
+    init_scoring();
+    init_client();
+    init_packages();
+    init_types();
+  }
+});
+
+// src/pipeline/single.ts
+import { and, eq as eq2, isNotNull, sql as sql2 } from "drizzle-orm";
+async function getSeedCategory(db, name) {
+  const [row] = await db.select({ category: seedPackages.category }).from(seedPackages).where(eq2(seedPackages.name, name)).limit(1);
+  return row?.category ?? null;
+}
+async function getCategoryMedianBundle(db, category) {
+  const [row] = await db.select({
+    m: sql2`percentile_cont(0.5) within group (order by ${packages.bundleMinGzipKb})`
+  }).from(packages).where(and(eq2(packages.category, category), isNotNull(packages.bundleMinGzipKb)));
+  return row?.m ?? null;
+}
+async function syncOnePackage(db, name, opts = {}) {
+  const config = getConfig();
+  const now = /* @__PURE__ */ new Date();
+  const existing = await getPackageByName(db, name);
+  const category = opts.category ?? existing?.category ?? await getSeedCategory(db, name) ?? null;
+  const prefetchedWeekly = await fetchWeeklyDownloads(name).catch(() => null);
+  const signals = await collectSignals(name, category, {
+    githubToken: config.GITHUB_TOKEN,
+    prefetchedWeekly
+  });
+  const input = toScoringInput(signals, category);
+  const summaryInput = await buildSummaryInput(signals, category);
+  const { summary, usageGuide } = await createSummaryProvider().generate(summaryInput);
+  const median2 = category ? await getCategoryMedianBundle(db, category) : null;
+  const breakdown = {
+    maintenance: computeMaintenance(input, now),
+    adoption: computeAdoption(input),
+    reliability: computeReliability(input),
+    efficiency: computeEfficiency(input.bundleMinGzipKb, category, median2)
+  };
+  const healthScore = computeHealthScore(breakdown);
+  const confidence = computeConfidence(input, now);
+  const [embedding] = await createEmbeddingProvider().embed([
+    buildEmbeddingText({ name, category, summary, description: signals.registry?.description ?? null })
+  ]);
+  await upsertPackage(
+    db,
+    assemblePackageRow({
+      name,
+      category,
+      signals,
+      input,
+      summary,
+      usageGuide,
+      confidence,
+      breakdown,
+      healthScore,
+      embedding: embedding ?? null,
+      now
+    })
+  );
+  return await getPackageByName(db, name);
+}
+async function getOrFetchPackage(db, name) {
+  const existing = await getPackageByName(db, name);
+  if (existing) return { row: existing, wasTracked: true, existsOnNpm: true };
+  const exists = await npmPackageExists(name);
+  if (!exists) return { row: null, wasTracked: false, existsOnNpm: false };
+  const row = await syncOnePackage(db, name);
+  await ensureSeedEntry(db, name, row.category);
+  return { row, wasTracked: false, existsOnNpm: true };
+}
+var init_single = __esm({
+  "src/pipeline/single.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_collect();
+    init_sources();
+    init_summarize();
+    init_scoring();
+    init_embeddings();
+    init_packages();
+    init_schema();
+    init_sync();
+  }
+});
+
+// src/search/categoryInference.ts
+function inferCategory(need) {
+  const text2 = need.toLowerCase();
+  for (const rule of RULES) {
+    if (rule.patterns.test(text2)) return rule.category;
+  }
+  return null;
+}
+var RULES;
+var init_categoryInference = __esm({
+  "src/search/categoryInference.ts"() {
+    "use strict";
+    init_esm_shims();
+    RULES = [
+      { category: "meta-framework", patterns: /\b(meta-?framework|next\.?js|nuxt|remix|astro|gatsby|sveltekit|full-?stack framework)\b/ },
+      { category: "state-management", patterns: /\b(state management|global state|store|redux|zustand|jotai|mobx|atoms?)\b/ },
+      { category: "routing", patterns: /\b(rout(e|er|ing)|navigation|url matching)\b/ },
+      { category: "orm", patterns: /\b(orm|object-?relational|query builder|prisma|drizzle|sequelize|typeorm)\b/ },
+      { category: "database-client", patterns: /\b(database (driver|client)|postgres|mysql|mongo(db)?|redis|sqlite|db driver)\b/ },
+      { category: "ui-component-library", patterns: /\b(component library|ui kit|ui components?|design system|buttons?|modal|dialog)\b/ },
+      { category: "styling", patterns: /\b(styl(e|ing)|css|tailwind|sass|scss|class ?names?|theme)\b/ },
+      { category: "forms", patterns: /\b(forms?|form (state|library|handling)|input handling)\b/ },
+      { category: "validation", patterns: /\b(validat(e|ion|or)|schema|parse input|type ?safe parsing)\b/ },
+      { category: "data-fetching", patterns: /\b(data fetching|server state|react query|swr|graphql client|caching queries)\b/ },
+      { category: "http-client", patterns: /\b(http client|fetch wrapper|rest client|make (a )?request|ajax|api calls?)\b/ },
+      { category: "auth", patterns: /\b(auth(entication|orization)?|login|session|jwt|oauth|password hashing)\b/ },
+      { category: "testing", patterns: /\b(test(ing|s)?|unit test|e2e|assertion|mocking|test runner)\b/ },
+      { category: "bundler", patterns: /\b(bundler|bundle (modules?|code)|webpack|rollup|esbuild|parcel)\b/ },
+      { category: "build-tool", patterns: /\b(build tool|dev server|monorepo|task runner|compile|transpile)\b/ },
+      // date-time precedes linting: "date formatting" must not be captured by linting's
+      // bare "formatting" token before the date rule is reached (first-match-wins).
+      { category: "date-time", patterns: /\b(dates?|date ?time|time(zone)?s?|calendar|parse dates?|format dates?)\b/ },
+      { category: "linting", patterns: /\b(lint(er|ing)?|formatter|formatting|code (quality|style|format)|prettier|eslint)\b/ },
+      { category: "animation", patterns: /\b(animat(e|ion)|motion|transition|spring|gsap|3d)\b/ },
+      { category: "charts", patterns: /\b(charts?|graphs?|data ?vis(ualization)?|plots?|dashboards?)\b/ },
+      { category: "i18n", patterns: /\b(i18n|internationali[sz]ation|localization|translat(e|ion)|locale)\b/ },
+      { category: "framework", patterns: /\b(framework|react|vue|svelte|angular|web server|backend framework)\b/ },
+      { category: "utility", patterns: /\b(debounce|throttle|deep ?clone|slugify|uuid|util(ity|ities)?|helper|lodash|retry)\b/ }
+    ];
+  }
+});
+
+// src/search/recommend.ts
+import { and as and2, cosineDistance, desc, eq as eq3, isNotNull as isNotNull2, lte, sql as sql3 } from "drizzle-orm";
+async function recommend(db, opts, provider = createEmbeddingProvider()) {
+  const limit = Math.min(Math.max(opts.limit ?? 3, 1), 5);
+  const [queryVec] = await provider.embed([opts.need]);
+  if (!queryVec) return [];
+  const category = opts.category ?? inferCategory(opts.need);
+  const pool = Math.max(limit * 5, 25);
+  let rows = await runQuery(db, queryVec, opts.constraints, category, pool);
+  if (category && rows.length < limit) {
+    const broad = await runQuery(db, queryVec, opts.constraints, null, pool);
+    const seen = new Set(rows.map((r) => r.name));
+    rows = rows.concat(broad.filter((r) => !seen.has(r.name)));
+  }
+  if (rows.length === 0) return [];
+  const ranked = rows.map((r) => {
+    const simNorm = Math.max(0, Math.min(1, (r.similarity + 1) / 2));
+    const health = (r.healthScore ?? 0) / 100;
+    return { row: r, score: SIM_WEIGHT * simNorm + HEALTH_WEIGHT * health };
+  }).sort((a, b) => b.score - a.score).slice(0, limit);
+  return ranked.map(({ row }) => toCandidate(row));
+}
+async function runQuery(db, queryVec, constraints, category, pool) {
+  const similarity = sql3`1 - (${cosineDistance(packages.embedding, queryVec)})`;
+  const conditions = [isNotNull2(packages.embedding)];
+  if (category) conditions.push(eq3(packages.category, category));
+  if (constraints?.license) conditions.push(eq3(packages.license, constraints.license));
+  if (constraints?.maxBundleKb !== void 0) {
+    conditions.push(lte(packages.bundleMinGzipKb, constraints.maxBundleKb));
+  }
+  if (constraints?.minConfidence) {
+    const allowed = ["proven", "emerging", "unproven"].filter(
+      (c) => CONFIDENCE_RANK[c] >= CONFIDENCE_RANK[constraints.minConfidence]
+    );
+    conditions.push(
+      sql3`${packages.confidence} in ${sql3.raw(`(${allowed.map((c) => `'${c}'`).join(",")})`)}`
+    );
+  }
+  return db.select({
+    name: packages.name,
+    category: packages.category,
+    healthScore: packages.healthScore,
+    confidence: packages.confidence,
+    latestVersion: packages.latestVersion,
+    weeklyDownloads: packages.weeklyDownloads,
+    lastReleaseAt: packages.lastReleaseAt,
+    repoUrl: packages.repoUrl,
+    similarity
+  }).from(packages).where(and2(...conditions)).orderBy(desc(similarity)).limit(pool);
+}
+function toCandidate(row) {
+  return {
+    name: row.name,
+    category: row.category,
+    healthScore: row.healthScore ?? 0,
+    confidence: row.confidence ?? "unproven",
+    why: buildWhy(row),
+    latestVersion: row.latestVersion,
+    weeklyDownloads: row.weeklyDownloads,
+    lastReleaseAt: row.lastReleaseAt ? row.lastReleaseAt.toISOString() : null,
+    repoUrl: row.repoUrl
+  };
+}
+function buildWhy(row) {
+  const parts = [];
+  if (row.confidence) parts.push(row.confidence);
+  if (row.weeklyDownloads) parts.push(`${formatDownloads(row.weeklyDownloads)} weekly downloads`);
+  if (row.healthScore !== null) parts.push(`health ${row.healthScore}`);
+  return parts.join(", ") || "tracked package";
+}
+function formatDownloads(n) {
+  if (n >= 1e6) return `${Math.round(n / 1e5) / 10}M`;
+  if (n >= 1e3) return `${Math.round(n / 1e3)}k`;
+  return String(n);
+}
+var CONFIDENCE_RANK, SIM_WEIGHT, HEALTH_WEIGHT;
+var init_recommend = __esm({
+  "src/search/recommend.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_schema();
+    init_categoryInference();
+    init_embeddings();
+    CONFIDENCE_RANK = { unproven: 0, emerging: 1, proven: 2 };
+    SIM_WEIGHT = 0.6;
+    HEALTH_WEIGHT = 0.4;
+  }
+});
+
+// src/mcp/handlers.ts
+import { sql as sql4 } from "drizzle-orm";
+function isStale(dataAsOf) {
+  if (!dataAsOf) return true;
+  return Date.now() - dataAsOf.getTime() > STALENESS_DAYS * DAY_MS2;
+}
+function withinDays(date, days) {
+  return date ? Date.now() - date.getTime() <= days * DAY_MS2 : false;
+}
+function topAdvisories(advisories, max = 5) {
+  if (!advisories?.length) return [];
+  return [...advisories].sort((a, b) => SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity]).slice(0, max);
+}
+function rowToEvaluate(row) {
+  const breakdown = row.scoreBreakdown ?? {
+    maintenance: 0,
+    adoption: 0,
+    reliability: 0,
+    efficiency: null
+  };
+  return {
+    dataAsOf: (row.dataAsOf ?? /* @__PURE__ */ new Date()).toISOString(),
+    stale: isStale(row.dataAsOf) || void 0,
+    name: row.name,
+    category: row.category,
+    healthScore: row.healthScore ?? 0,
+    confidence: row.confidence ?? "unproven",
+    scoreBreakdown: breakdown,
+    latestVersion: row.latestVersion,
+    lastReleaseAt: row.lastReleaseAt ? row.lastReleaseAt.toISOString() : null,
+    weeklyDownloads: row.weeklyDownloads,
+    downloadGrowth90d: row.downloadGrowth90d,
+    dependentsCount: row.dependentsCount,
+    scorecard: row.scorecard,
+    bundleMinGzipKb: row.bundleMinGzipKb,
+    deprecated: row.deprecated,
+    archived: row.archived,
+    advisories: topAdvisories(row.advisories),
+    summary: row.summary ? truncateSentences(row.summary, 3) : null,
+    usageGuide: row.usageGuide ?? null,
+    repoUrl: row.repoUrl
+  };
+}
+async function latestDataAsOf(db) {
+  const [row] = await db.select({ m: sql4`max(${packages.dataAsOf})` }).from(packages);
+  return new Date(row?.m ?? Date.now()).toISOString();
+}
+async function handleRecommend(db, input) {
+  const candidates = await recommend(db, {
+    need: input.need,
+    category: input.category,
+    constraints: input.constraints,
+    limit: 5
+  });
+  return { dataAsOf: await latestDataAsOf(db), candidates };
+}
+async function handleEvaluate(db, input) {
+  const { row, existsOnNpm } = await getOrFetchPackage(db, input.package);
+  if (!row) {
+    return {
+      tracked: false,
+      suggestion: existsOnNpm ? `"${input.package}" exists on npm but could not be scored right now; try again.` : `"${input.package}" was not found on the npm registry. Check the package name.`
+    };
+  }
+  return rowToEvaluate(row);
+}
+async function handleCompare(db, input) {
+  const results = await Promise.all(input.packages.map((name) => getOrFetchPackage(db, name)));
+  const rows = results.map((r) => r.row).filter((row) => row !== null).map(rowToEvaluate).sort((a, b) => b.healthScore - a.healthScore);
+  const missing = input.packages.filter(
+    (name) => !rows.some((r) => r.name === name)
+  );
+  return { dataAsOf: await latestDataAsOf(db), rows, ...missing.length ? { missing } : {} };
+}
+async function handleVerify(db, input) {
+  const name = input.package;
+  const exists = await npmPackageExists(name);
+  if (!exists) {
+    return {
+      exists: false,
+      tracked: false,
+      deprecated: false,
+      archived: false,
+      latestVersion: null,
+      weeklyDownloads: null,
+      riskFlags: ["not-found-on-registry"],
+      confidence: null,
+      advisoryCount: 0
+    };
+  }
+  const registry = await fetchNpmRegistry(name).catch(() => null);
+  const { row, wasTracked } = await getOrFetchPackage(db, name);
+  const weeklyDownloads = row?.weeklyDownloads ?? null;
+  const advisoryCount = row?.advisories?.length ?? 0;
+  const deprecated = Boolean(row?.deprecated || registry?.deprecated);
+  const archived = Boolean(row?.archived);
+  const riskFlags = [];
+  if (weeklyDownloads === null || weeklyDownloads === 0) riskFlags.push("zero-downloads");
+  else if (weeklyDownloads < 1e3) riskFlags.push("low-downloads");
+  if (withinDays(registry?.firstPublishedAt ?? null, 7)) riskFlags.push("published-within-7-days");
+  if (registry?.maintainersCount === 1) riskFlags.push("single-maintainer");
+  if (advisoryCount > 0) riskFlags.push("has-known-advisory");
+  if (deprecated) riskFlags.push("deprecated");
+  if (archived) riskFlags.push("archived");
+  return {
+    exists: true,
+    tracked: wasTracked,
+    deprecated,
+    archived,
+    latestVersion: registry?.latestVersion ?? row?.latestVersion ?? null,
+    weeklyDownloads,
+    riskFlags,
+    confidence: row?.confidence ?? null,
+    advisoryCount
+  };
+}
+var SEVERITY_RANK, DAY_MS2;
+var init_handlers = __esm({
+  "src/mcp/handlers.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_schema();
+    init_sources();
+    init_summarize();
+    init_single();
+    init_recommend();
+    SEVERITY_RANK = {
+      critical: 4,
+      high: 3,
+      moderate: 2,
+      low: 1,
+      info: 0
+    };
+    DAY_MS2 = 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/mcp/diagram.ts
+import { inArray } from "drizzle-orm";
+function layerFor(item) {
+  if (!item.category) return UNCLASSIFIED;
+  if (item.category === "framework" && BACKEND_FRAMEWORKS.has(item.label)) return "Backend";
+  return LAYER_OF[item.category] ?? UNCLASSIFIED;
+}
+function nodeId(label, i) {
+  return `n${i}_${label.replace(/[^a-zA-Z0-9]/g, "_")}`;
+}
+function buildMermaid(items) {
+  const byLayer = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const layer = layerFor(item);
+    const list = byLayer.get(layer) ?? [];
+    list.push(item);
+    byLayer.set(layer, list);
+  }
+  const lines = ["flowchart TD", "  user([User])"];
+  const ids = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const repNode = /* @__PURE__ */ new Map();
+  const emitLayer = (layer) => {
+    const list = byLayer.get(layer);
+    if (!list?.length) return;
+    lines.push(`  subgraph ${layer.replace(/\s+/g, "_")}["${layer}"]`);
+    for (const item of list) {
+      const id = nodeId(item.label, counter++);
+      ids.set(item.label, id);
+      if (!repNode.has(layer)) repNode.set(layer, id);
+      const text2 = layer === UNCLASSIFIED ? item.label : `${item.category}: ${item.label}`;
+      lines.push(`    ${id}["${text2}"]`);
+    }
+    lines.push("  end");
+  };
+  for (const layer of FLOW_LAYERS) emitLayer(layer);
+  emitLayer("Tooling");
+  emitLayer(UNCLASSIFIED);
+  const present = FLOW_LAYERS.filter((l) => byLayer.has(l));
+  let prev = "user";
+  for (const layer of present) {
+    lines.push(`  ${prev} --> ${repNode.get(layer)}`);
+    prev = repNode.get(layer);
+  }
+  if (byLayer.has("Data")) lines.push(`  ${repNode.get("Data")} --> db[(Database)]`);
+  return lines.join("\n");
+}
+async function handleDiagram(db, input) {
+  if (!input.stack?.length) {
+    return {
+      mermaid: "flowchart TD\n  user([User]) --> app[Application]",
+      note: "Provide a `stack` of package names to diagram. lurq labels a stack you choose; it does not infer an architecture from a description."
+    };
+  }
+  const rows = await db.select({ name: packages.name, category: packages.category }).from(packages).where(inArray(packages.name, input.stack));
+  const known = new Map(rows.map((r) => [r.name, r.category]));
+  const items = input.stack.map((name) => ({
+    label: name,
+    category: known.get(name) ?? inferCategory(name)
+  }));
+  const unclassified = items.filter((i) => layerFor(i) === UNCLASSIFIED).map((i) => i.label);
+  const note = unclassified.length ? `Reference pattern derived from the provided stack \u2014 partial, not authoritative. Could not place ${unclassified.length} package(s): ${unclassified.join(", ")} (not in lurq's index and no category match) \u2014 shown under Unclassified, outside the flow.` : "Reference pattern derived from the provided stack. A labeled starting point, not a validated architecture.";
+  return { mermaid: buildMermaid(items), note };
+}
+var UNCLASSIFIED, LAYER_OF, FLOW_LAYERS, BACKEND_FRAMEWORKS;
+var init_diagram = __esm({
+  "src/mcp/diagram.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_categoryInference();
+    init_schema();
+    UNCLASSIFIED = "Unclassified";
+    LAYER_OF = {
+      framework: "Presentation",
+      "meta-framework": "Presentation",
+      "ui-component-library": "Presentation",
+      styling: "Presentation",
+      animation: "Presentation",
+      charts: "Presentation",
+      "state-management": "Client Logic",
+      routing: "Client Logic",
+      forms: "Client Logic",
+      validation: "Client Logic",
+      "data-fetching": "Client Logic",
+      "http-client": "Client Logic",
+      i18n: "Client Logic",
+      "date-time": "Client Logic",
+      utility: "Client Logic",
+      auth: "Backend",
+      orm: "Data",
+      "database-client": "Data",
+      "build-tool": "Tooling",
+      bundler: "Tooling",
+      linting: "Tooling",
+      testing: "Tooling"
+    };
+    FLOW_LAYERS = ["Presentation", "Client Logic", "Backend", "Data"];
+    BACKEND_FRAMEWORKS = /* @__PURE__ */ new Set([
+      "express",
+      "fastify",
+      "koa",
+      "hono",
+      "@nestjs/core",
+      "@hapi/hapi"
+    ]);
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  buildMcpServer: () => buildMcpServer,
+  startMcpServer: () => startMcpServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+function json(obj) {
+  return { content: [{ type: "text", text: JSON.stringify(obj) }] };
+}
+function buildMcpServer(db) {
+  const server = new McpServer({ name: SERVER_NAME, version: VERSION });
+  server.registerTool(
+    "recommend",
+    {
+      title: "Recommend packages",
+      description: "Recommend the best current npm packages for a described need \u2014 fresh, objectively scored, with confidence labels. Call before choosing or hand-rolling a dependency.",
+      inputSchema: {
+        need: z2.string().min(1).describe("Natural-language description of what you need"),
+        category: categoryEnum.optional().describe("Optional taxonomy category to restrict to"),
+        constraints: constraintsSchema
+      }
+    },
+    async (args) => json(await handleRecommend(db, args))
+  );
+  server.registerTool(
+    "evaluate",
+    {
+      title: "Evaluate a package",
+      description: "Full evidence read for one npm package: scores, signals, advisories, summary, and a usage guide. Fetches & scores on demand if not yet tracked.",
+      inputSchema: {
+        package: z2.string().min(1).describe("npm package name")
+      }
+    },
+    async (args) => json(await handleEvaluate(db, args))
+  );
+  server.registerTool(
+    "compare",
+    {
+      title: "Compare packages",
+      description: "Side-by-side comparison of 2\u20135 npm packages, ranked by health score.",
+      inputSchema: {
+        packages: z2.array(z2.string().min(1)).min(2).max(5).describe("2\u20135 npm package names")
+      }
+    },
+    async (args) => json(await handleCompare(db, args))
+  );
+  server.registerTool(
+    "verify",
+    {
+      title: "Verify a package",
+      description: "Confirm an npm package is real, healthy, and not risky before installing \u2014 guards against hallucinated or typosquatted dependency names. Checks the live registry.",
+      inputSchema: {
+        package: z2.string().min(1).describe("npm package name to verify")
+      }
+    },
+    async (args) => json(await handleVerify(db, args))
+  );
+  server.registerTool(
+    "diagram",
+    {
+      title: "Reference architecture diagram",
+      description: "Emit a reference-architecture Mermaid diagram for a stack you have already chosen (package names). A labeled starting point keyed by layer \u2014 not a validated architecture, and not an architecture designer.",
+      inputSchema: {
+        stack: z2.array(z2.string()).optional().describe("Package names that make up the stack; omit or empty to get usage guidance")
+      }
+    },
+    async (args) => json(await handleDiagram(db, args))
+  );
+  return server;
+}
+async function startMcpServer() {
+  const { db, close } = createDb();
+  const server = buildMcpServer(db);
+  const shutdown = async () => {
+    try {
+      await close();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info(`${SERVER_NAME} MCP server v${VERSION} running on stdio.`);
+}
+var categoryEnum, confidenceEnum, constraintsSchema;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_types();
+    init_client();
+    init_logger();
+    init_handlers();
+    init_diagram();
+    categoryEnum = z2.enum(CATEGORIES);
+    confidenceEnum = z2.enum(["proven", "emerging", "unproven"]);
+    constraintsSchema = z2.object({
+      runtime: z2.enum(["browser", "node", "both"]).optional(),
+      license: z2.string().optional(),
+      maxBundleKb: z2.number().positive().optional(),
+      minConfidence: confidenceEnum.optional()
+    }).optional();
+  }
+});
+
+// src/pipeline/index.ts
+var pipeline_exports = {};
+__export(pipeline_exports, {
+  runSync: () => runSync
+});
+var init_pipeline = __esm({
+  "src/pipeline/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sync();
+  }
+});
+
+// src/cli/format.ts
+function table(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(width(h), ...rows.map((r) => width(r[i] ?? ""))));
+  const pad = (s, w) => s + " ".repeat(Math.max(0, w - width(s)));
+  const line = (cells) => cells.map((c, i) => pad(c, widths[i])).join("  ");
+  const out = [bold(line(headers)), dim(widths.map((w) => "\u2500".repeat(w)).join("  "))];
+  for (const r of rows) out.push(line(r));
+  return out.join("\n");
+}
+function detail(pairs) {
+  const labelWidth = Math.max(...pairs.map(([k]) => k.length));
+  return pairs.map(([k, v]) => `${dim((k + ":").padEnd(labelWidth + 1))} ${v}`).join("\n");
+}
+function formatNumber(n) {
+  if (n == null) return "\u2014";
+  if (n >= 1e6) return `${Math.round(n / 1e5) / 10}M`;
+  if (n >= 1e3) return `${Math.round(n / 100) / 10}k`;
+  return String(n);
+}
+function formatDate(iso) {
+  return iso ? iso.slice(0, 10) : "\u2014";
+}
+function formatPercent(fraction) {
+  if (fraction == null) return "\u2014";
+  const pct = Math.round(fraction * 1e3) / 10;
+  return `${pct > 0 ? "+" : ""}${pct}%`;
+}
+function confidenceLabel(c) {
+  if (c === "proven") return green(c);
+  if (c === "emerging") return yellow(c);
+  return red(c);
+}
+var ESC, wrap, bold, dim, red, green, yellow, ANSI_RE, width;
+var init_format = __esm({
+  "src/cli/format.ts"() {
+    "use strict";
+    init_esm_shims();
+    ESC = "\x1B[";
+    wrap = (code, s) => `${ESC}${code}m${s}${ESC}0m`;
+    bold = (s) => wrap("1", s);
+    dim = (s) => wrap("2", s);
+    red = (s) => wrap("31", s);
+    green = (s) => wrap("32", s);
+    yellow = (s) => wrap("33", s);
+    ANSI_RE = /\[[0-9;]*m/g;
+    width = (s) => s.replace(ANSI_RE, "").length;
+  }
+});
+
+// src/cli/commands.ts
+var commands_exports = {};
+__export(commands_exports, {
+  runCompare: () => runCompare,
+  runEvaluate: () => runEvaluate,
+  runRecommend: () => runRecommend,
+  runVerify: () => runVerify
+});
+async function withDb(fn) {
+  requireConfig(["DATABASE_URL"]);
+  const handle = createDb();
+  try {
+    return await fn(handle.db);
+  } finally {
+    await handle.close();
+  }
+}
+async function runRecommend(need, opts) {
+  if (opts.category && !isCategory(opts.category)) {
+    throw new Error(`Unknown category "${opts.category}".`);
+  }
+  await withDb(async (db) => {
+    const res = await handleRecommend(db, {
+      need,
+      category: opts.category,
+      constraints: opts.minConfidence ? { minConfidence: opts.minConfidence } : void 0
+    });
+    if (opts.json) return console.log(JSON.stringify(res, null, 2));
+    if (res.candidates.length === 0) {
+      console.log("No matching packages found.");
+      return;
+    }
+    console.log(
+      table(
+        ["Package", "Health", "Confidence", "Weekly", "Latest", "Category"],
+        res.candidates.map((c) => [
+          c.name,
+          String(c.healthScore),
+          confidenceLabel(c.confidence),
+          formatNumber(c.weeklyDownloads),
+          c.latestVersion ?? "\u2014",
+          c.category ?? "\u2014"
+        ])
+      )
+    );
+    console.log(dim(`
+data as of ${formatDate(res.dataAsOf)}`));
+  });
+}
+async function runEvaluate(pkg, opts) {
+  await withDb(async (db) => {
+    const res = await handleEvaluate(db, { package: pkg });
+    if (opts.json) return console.log(JSON.stringify(res, null, 2));
+    if ("tracked" in res) {
+      console.log(res.suggestion);
+      return;
+    }
+    console.log(bold(res.name) + (res.category ? dim(`  (${res.category})`) : ""));
+    const b = res.scoreBreakdown;
+    console.log(
+      detail([
+        ["health", `${res.healthScore}  ${confidenceLabel(res.confidence)}`],
+        [
+          "breakdown",
+          `maint ${b.maintenance} \xB7 adopt ${b.adoption} \xB7 rel ${b.reliability} \xB7 eff ${b.efficiency ?? "\u2014"}`
+        ],
+        ["version", res.latestVersion ?? "\u2014"],
+        ["weekly dl", `${formatNumber(res.weeklyDownloads)}  (${formatPercent(res.downloadGrowth90d)} 90d)`],
+        ["scorecard", res.scorecard != null ? String(res.scorecard) : "\u2014"],
+        ["bundle", res.bundleMinGzipKb != null ? `${res.bundleMinGzipKb} KB gzip` : "\u2014"],
+        ["released", formatDate(res.lastReleaseAt)],
+        ["flags", [res.deprecated && "deprecated", res.archived && "archived"].filter(Boolean).join(", ") || "none"],
+        ["advisories", res.advisories.length ? res.advisories.map((a) => `${a.severity}`).join(", ") : "none"],
+        ["repo", res.repoUrl ?? "\u2014"]
+      ])
+    );
+    if (res.summary) console.log("\n" + res.summary);
+    if (res.usageGuide) {
+      const g = res.usageGuide;
+      console.log(
+        "\n" + detail(
+          [
+            ["what", g.whatItIs],
+            ["when", g.whenToUse],
+            g.whenNotToUse ? ["when not", g.whenNotToUse] : null,
+            ["fits", g.whereItFits],
+            g.howToWireIn ? ["wire-in", g.howToWireIn] : null
+          ].filter(Boolean)
+        )
+      );
+    }
+    console.log(dim(`
+data as of ${formatDate(res.dataAsOf)}${res.stale ? "  (stale)" : ""}`));
+  });
+}
+async function runCompare(pkgs, opts) {
+  await withDb(async (db) => {
+    const res = await handleCompare(db, { packages: pkgs });
+    if (opts.json) return console.log(JSON.stringify(res, null, 2));
+    console.log(
+      table(
+        ["Package", "Health", "Confidence", "Weekly", "90d", "Scorecard", "Released"],
+        res.rows.map((r) => [
+          r.name,
+          String(r.healthScore),
+          confidenceLabel(r.confidence),
+          formatNumber(r.weeklyDownloads),
+          formatPercent(r.downloadGrowth90d),
+          r.scorecard != null ? String(r.scorecard) : "\u2014",
+          formatDate(r.lastReleaseAt)
+        ])
+      )
+    );
+    if (res.missing?.length) console.log(dim(`
+not found: ${res.missing.join(", ")}`));
+    console.log(dim(`data as of ${formatDate(res.dataAsOf)}`));
+  });
+}
+async function runVerify(pkg, opts) {
+  await withDb(async (db) => {
+    const res = await handleVerify(db, { package: pkg });
+    if (opts.json) return console.log(JSON.stringify(res, null, 2));
+    const verdict = !res.exists ? red("\u2717 NOT FOUND on npm") : res.deprecated || res.archived || res.advisoryCount > 0 ? yellow("\u26A0 exists, but risky") : green("\u2713 looks safe");
+    console.log(`${bold(pkg)}  ${verdict}`);
+    console.log(
+      detail([
+        ["version", res.latestVersion ?? "\u2014"],
+        ["weekly dl", formatNumber(res.weeklyDownloads)],
+        ["confidence", res.confidence ? confidenceLabel(res.confidence) : "\u2014"],
+        ["advisories", String(res.advisoryCount)],
+        ["risk flags", res.riskFlags.length ? yellow(res.riskFlags.join(", ")) : "none"]
+      ])
+    );
+  });
+}
+var init_commands = __esm({
+  "src/cli/commands.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_types();
+    init_client();
+    init_handlers();
+    init_format();
+  }
+});
+
+// src/core/paths.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function packageRoot() {
+  if (cachedRoot) return cachedRoot;
+  let dir = dirname2(fileURLToPath2(import.meta.url));
+  for (; ; ) {
+    if (existsSync2(join2(dir, "package.json"))) {
+      cachedRoot = dir;
+      return dir;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  cachedRoot = process.cwd();
+  return cachedRoot;
+}
+function migrationsDir() {
+  return join2(packageRoot(), "drizzle");
+}
+function seedJsonPath() {
+  return join2(packageRoot(), "src", "data", "seed.json");
+}
+var cachedRoot;
+var init_paths = __esm({
+  "src/core/paths.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/installSkill.ts
+var installSkill_exports = {};
+__export(installSkill_exports, {
+  SUPPORTED_AGENTS: () => SUPPORTED_AGENTS,
+  buildServerEntry: () => buildServerEntry,
+  buildTomlBlock: () => buildTomlBlock,
+  runInstallSkill: () => runInstallSkill
+});
+import { existsSync as existsSync3, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { copyFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join3 } from "path";
+function home(...p) {
+  return join3(homedir2(), ...p);
+}
+function agentSpecs() {
+  return [
+    {
+      id: "claude-code",
+      label: "Claude Code",
+      format: "mcpServers",
+      path: home(".claude.json"),
+      detected: existsSync3(home(".claude.json")) || existsSync3(home(".claude"))
+    },
+    {
+      id: "cursor",
+      label: "Cursor",
+      format: "mcpServers",
+      path: home(".cursor", "mcp.json"),
+      detected: existsSync3(home(".cursor"))
+    },
+    {
+      id: "windsurf",
+      label: "Windsurf",
+      format: "mcpServers",
+      path: home(".codeium", "windsurf", "mcp_config.json"),
+      detected: existsSync3(home(".codeium"))
+    },
+    {
+      id: "copilot",
+      label: "VS Code / GitHub Copilot",
+      format: "servers",
+      path: home("Library", "Application Support", "Code", "User", "mcp.json"),
+      detected: existsSync3(home("Library", "Application Support", "Code", "User"))
+    },
+    {
+      id: "codex",
+      label: "OpenAI Codex CLI",
+      format: "toml",
+      path: home(".codex", "config.toml"),
+      detected: existsSync3(home(".codex"))
+    }
+  ];
+}
+function collectEnv() {
+  const env = {};
+  for (const key of ENV_KEYS) {
+    const value = process.env[key];
+    if (value) env[key] = value;
+  }
+  return env;
+}
+function readJsonObject(path2) {
+  if (!existsSync3(path2)) return {};
+  const text2 = readFileSync(path2, "utf8").trim();
+  if (!text2) return {};
+  return JSON.parse(text2);
+}
+function writeJson(path2, obj) {
+  mkdirSync(dirname3(path2), { recursive: true });
+  writeFileSync(path2, JSON.stringify(obj, null, 2) + "\n", "utf8");
+}
+function buildServerEntry(env, withType) {
+  const entry = { command: "npx", args: ["-y", PACKAGE_NAME, "serve"] };
+  if (withType) entry.type = "stdio";
+  if (Object.keys(env).length) entry.env = env;
+  return entry;
+}
+function installJson(spec, env) {
+  const key = spec.format === "servers" ? "servers" : "mcpServers";
+  const config = readJsonObject(spec.path);
+  if (typeof config[key] !== "object" || config[key] === null) config[key] = {};
+  config[key].lurq = buildServerEntry(env, spec.format === "servers");
+  writeJson(spec.path, config);
+  return { agent: spec.id, path: spec.path, status: "installed" };
+}
+function buildTomlBlock(env) {
+  const lines = ["[mcp_servers.lurq]", 'command = "npx"', `args = ["-y", "${PACKAGE_NAME}", "serve"]`];
+  if (Object.keys(env).length) {
+    lines.push("", "[mcp_servers.lurq.env]");
+    for (const [k, v] of Object.entries(env)) lines.push(`${k} = ${JSON.stringify(v)}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function installToml(spec, env) {
+  const existing = existsSync3(spec.path) ? readFileSync(spec.path, "utf8") : "";
+  if (existing.includes("[mcp_servers.lurq]")) {
+    return {
+      agent: spec.id,
+      path: spec.path,
+      status: "skipped",
+      message: "lurq already present; edit manually to change it."
+    };
+  }
+  mkdirSync(dirname3(spec.path), { recursive: true });
+  const sep = existing && !existing.endsWith("\n") ? "\n\n" : existing ? "\n" : "";
+  writeFileSync(spec.path, existing + sep + buildTomlBlock(env), "utf8");
+  return { agent: spec.id, path: spec.path, status: "installed" };
+}
+function installInstructionsFile() {
+  const src = join3(packageRoot(), "templates", "skill-instructions.md");
+  if (!existsSync3(src)) return null;
+  const destDir = home(".lurq");
+  const dest = join3(destDir, "skill-instructions.md");
+  mkdirSync(destDir, { recursive: true });
+  copyFileSync(src, dest);
+  return dest;
+}
+async function runInstallSkill(opts) {
+  const target = opts.agent ?? "claude-code";
+  const specs = agentSpecs();
+  const env = collectEnv();
+  let selected;
+  if (target === "all") {
+    selected = specs.filter((s) => s.detected);
+    if (selected.length === 0) {
+      console.log("No supported agents detected on this machine.");
+      return;
+    }
+  } else {
+    const spec = specs.find((s) => s.id === target);
+    if (!spec) {
+      throw new Error(
+        `Unknown agent "${target}". Supported: ${SUPPORTED_AGENTS.join(", ")}, all.`
+      );
+    }
+    selected = [spec];
+  }
+  if (!env.DATABASE_URL) {
+    logger.warn(
+      "DATABASE_URL is not set in the current environment \u2014 the installed server entry will have no DATABASE_URL. Set it (in .env) and re-run, or edit the config."
+    );
+  }
+  const results = [];
+  for (const spec of selected) {
+    try {
+      results.push(spec.format === "toml" ? installToml(spec, env) : installJson(spec, env));
+    } catch (err) {
+      results.push({
+        agent: spec.id,
+        path: spec.path,
+        status: "error",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const instructionsPath = installInstructionsFile();
+  console.log("lurq MCP server registration:");
+  for (const r of results) {
+    const spec = specs.find((s) => s.id === r.agent);
+    const mark = r.status === "installed" ? "\u2713" : r.status === "skipped" ? "\u2022" : "\u2717";
+    console.log(`  ${mark} ${spec.label.padEnd(26)} ${r.path}${r.message ? `  (${r.message})` : ""}`);
+  }
+  if (instructionsPath) console.log(`
+Skill instructions written to ${instructionsPath}`);
+  console.log("\nNext steps:");
+  console.log("  1. Ensure DATABASE_URL (and any API keys) are set in the config env above.");
+  console.log("  2. Restart the agent so it picks up the new MCP server.");
+  console.log("  3. Ask it to recommend a library \u2014 it should call lurq.");
+}
+var ENV_KEYS, SUPPORTED_AGENTS;
+var init_installSkill = __esm({
+  "src/cli/installSkill.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_logger();
+    init_paths();
+    ENV_KEYS = [
+      "DATABASE_URL",
+      "GITHUB_TOKEN",
+      "EMBEDDING_PROVIDER",
+      "EMBEDDING_API_KEY",
+      "EMBEDDING_MODEL",
+      "SUMMARY_PROVIDER",
+      "SUMMARY_API_KEY",
+      "SUMMARY_MODEL"
+    ];
+    SUPPORTED_AGENTS = ["claude-code", "cursor", "windsurf", "copilot", "codex"];
+  }
+});
+
+// src/db/seed.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { sql as sql5 } from "drizzle-orm";
+import { z as z3 } from "zod";
+function loadSeedFile(path2 = seedJsonPath()) {
+  const raw = JSON.parse(readFileSync2(path2, "utf8"));
+  const parsed = SeedFileSchema.parse(raw);
+  const byName = /* @__PURE__ */ new Map();
+  for (const entry of parsed) {
+    if (!byName.has(entry.name)) byName.set(entry.name, entry);
+  }
+  return [...byName.values()];
+}
+async function loadSeedPackages(db, path2) {
+  const entries = loadSeedFile(path2);
+  if (entries.length === 0) return 0;
+  await db.insert(seedPackages).values(entries.map((e) => ({ name: e.name, category: e.category ?? null }))).onConflictDoUpdate({
+    target: seedPackages.name,
+    // Refresh category to the incoming value on conflict (EXCLUDED.category).
+    set: { category: sql5`excluded.category` }
+  });
+  logger.info(`Loaded ${entries.length} packages into seed_packages.`);
+  return entries.length;
+}
+var SeedEntrySchema, SeedFileSchema;
+var init_seed = __esm({
+  "src/db/seed.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_types();
+    init_logger();
+    init_paths();
+    init_schema();
+    SeedEntrySchema = z3.object({
+      name: z3.string().min(1),
+      category: z3.enum(CATEGORIES).optional()
+    });
+    SeedFileSchema = z3.array(SeedEntrySchema);
+  }
+});
+
+// src/db/migrate.ts
+var migrate_exports = {};
+__export(migrate_exports, {
+  runMigrate: () => runMigrate,
+  runReset: () => runReset
+});
+import { migrate } from "drizzle-orm/postgres-js/migrator";
+async function ensureVectorExtension(handle) {
+  await handle.sql`CREATE EXTENSION IF NOT EXISTS vector`;
+}
+async function runMigrate() {
+  const handle = createDb({ max: 1 });
+  try {
+    logger.info("Ensuring pgvector extension\u2026");
+    await ensureVectorExtension(handle);
+    logger.info("Applying migrations\u2026");
+    await migrate(handle.db, { migrationsFolder: migrationsDir() });
+    logger.info("Loading seed list\u2026");
+    await loadSeedPackages(handle.db);
+    logger.info("Migration complete.");
+  } finally {
+    await handle.close();
+  }
+}
+async function runReset() {
+  const handle = createDb({ max: 1 });
+  try {
+    logger.warn("Dropping schema `public` (destructive)\u2026");
+    await handle.sql.unsafe("DROP SCHEMA IF EXISTS public CASCADE; CREATE SCHEMA public;");
+    await handle.sql`DROP SCHEMA IF EXISTS drizzle CASCADE`;
+  } finally {
+    await handle.close();
+  }
+  await runMigrate();
+  logger.info("Reset complete.");
+}
+var init_migrate = __esm({
+  "src/db/migrate.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_paths();
+    init_client();
+    init_seed();
+  }
+});
+
+// src/bin/lurq.ts
+init_esm_shims();
+
+// src/cli/index.ts
+init_esm_shims();
+init_constants();
+import { Command } from "commander";
+function buildProgram() {
+  const program = new Command();
+  program.name(SERVER_NAME).description(
+    "lurq - a fresh, objectively-scored index of JS/TS packages for AI coding agents."
+  ).version(VERSION, "-v, --version", "output the lurq version");
+  program.command("serve").description("start the MCP server over stdio (for agent integration)").action(async () => {
+    const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    await startMcpServer2();
+  });
+  program.command("sync").description("run ingestion: refresh scores for the seed list (or one package)").option("--full", "force a full re-sync, ignoring cache TTLs").option("--package <name>", "sync a single package by name").option("--json", "output the run summary as JSON").action(async (opts) => {
+    const { runSync: runSync2 } = await Promise.resolve().then(() => (init_pipeline(), pipeline_exports));
+    const summary = await runSync2({ full: opts.full, packageName: opts.package });
+    if (opts.json) console.log(JSON.stringify(summary, null, 2));
+    if (summary.status === "failed") process.exitCode = 1;
+  });
+  program.command("recommend").argument("<need>", "natural-language description of what you need").description("recommend the best current packages for a described need").option("--category <category>", "restrict to a taxonomy category").option("--min-confidence <level>", "proven | emerging | unproven").option("--json", "output JSON instead of a table").action(async (need, opts) => {
+    const { runRecommend: runRecommend2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+    await runRecommend2(need, opts);
+  });
+  program.command("evaluate").argument("<package>", "npm package name").description("full evidence read for one package (scores, signals, usage guide)").option("--json", "output JSON instead of a table").action(async (pkg, opts) => {
+    const { runEvaluate: runEvaluate2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+    await runEvaluate2(pkg, opts);
+  });
+  program.command("compare").argument("<packages...>", "2\u20135 npm package names").description("side-by-side comparison of packages, ranked by health").option("--json", "output JSON instead of a table").action(async (pkgs, opts) => {
+    const { runCompare: runCompare2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+    await runCompare2(pkgs, opts);
+  });
+  program.command("verify").argument("<package>", "npm package name").description("safety check: is this package real, healthy, and not risky?").option("--json", "output JSON instead of a table").action(async (pkg, opts) => {
+    const { runVerify: runVerify2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+    await runVerify2(pkg, opts);
+  });
+  program.command("install-skill").description("register lurq as an MCP server in supported AI assistants").option(
+    "--agent <agent>",
+    "claude-code | cursor | copilot | windsurf | codex | all",
+    "claude-code"
+  ).action(async (opts) => {
+    const { runInstallSkill: runInstallSkill2 } = await Promise.resolve().then(() => (init_installSkill(), installSkill_exports));
+    await runInstallSkill2(opts);
+  });
+  const db = program.command("db").description("database management");
+  db.command("migrate").description("apply database migrations and load the seed list").action(async () => {
+    const { runMigrate: runMigrate2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+    await runMigrate2();
+  });
+  db.command("reset").description("drop and recreate the schema (destructive)").option("--yes", "skip the confirmation prompt").action(async (opts) => {
+    if (!opts.yes) {
+      console.error(
+        "Refusing to reset without confirmation. Re-run with `--yes` to drop and recreate the schema."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const { runReset: runReset2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+    await runReset2();
+  });
+  return program;
+}
+
+// src/bin/lurq.ts
+init_config();
+init_logger();
+loadEnv();
+buildProgram().parseAsync(process.argv).catch((err) => {
+  logger.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=lurq.js.map