lurqrun 0.1.6 → 0.1.7

package/dist/mcpScanWorkflow-JPYCBGC4.js

@@ -0,0 +1,81 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  cliSpec
+} from "./chunk-B43LCXBM.js";
+import "./chunk-GPTKSNR6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/github/mcpScanWorkflow.ts
+init_esm_shims();
+var MCP_SCAN_WORKFLOW_PATH = ".github/workflows/lurq-mcp-scan.yml";
+var DEFAULT_CRON = "23 6 * * *";
+var CONFIG_PATHS = [".mcp.json", ".cursor/mcp.json", ".vscode/mcp.json", ".windsurf/mcp.json"];
+var VALID_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function secretNameFor(envName) {
+  return envName.toUpperCase().startsWith("GITHUB_") ? `MCP_${envName}` : envName;
+}
+function renderMcpScanWorkflow(opts = {}) {
+  const cron = opts.cron ?? DEFAULT_CRON;
+  if (cron.trim().split(/\s+/).length !== 5) throw new Error(`cron must have five fields; got "${cron}"`);
+  const failOn = opts.failOn ?? "high";
+  const issue = opts.githubIssue !== false;
+  const secrets = [...new Set(opts.secrets ?? [])].filter((s) => VALID_NAME.test(s) && s !== "LURQ_API_KEY").sort();
+  const serverWantsGithubToken = secrets.includes("GITHUB_TOKEN");
+  const env = [
+    "          LURQ_API_KEY: ${{ secrets.LURQ_API_KEY }}",
+    ...issue && !serverWantsGithubToken ? ["          GITHUB_TOKEN: ${{ github.token }}"] : [],
+    ...secrets.map((s) => `          ${s}: \${{ secrets.${secretNameFor(s)} }}`)
+  ].join("\n");
+  const uv = opts.needsUv ? `
+      # A server here launches with uvx.
+      - uses: astral-sh/setup-uv@v6
+` : "";
+  const permissions = issue ? `# Contents are read-only; nothing the scan reads can change code. The one write
+# keeps the pinned "lurq dashboard" issue current, with server text escaped.
+permissions:
+  contents: read
+  issues: write` : `# Read-only. The scan reads tool contracts; nothing it reads can write here.
+permissions:
+  contents: read`;
+  return `# Rescans the MCP servers committed to this repository: what each one exposes,
+# what its tools tell your agents, and what changed since the last scan.
+# Generated by \`lurq mcp-ci\`. Delete this file to stop it.
+name: lurq mcp scan
+
+on:
+  schedule:
+    - cron: '${cron}'
+  pull_request:
+    paths:
+${CONFIG_PATHS.map((p) => `      - '${p}'`).join("\n")}
+  workflow_dispatch: {}
+
+${permissions}
+
+jobs:
+  scan:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+${uv}
+      # Add each credential below as a repository secret (Settings \u2192 Secrets).
+      # A missing one is reported as "needs config", never as a broken server.
+      # --require-upload fails the job when the scan could not be recorded, so a
+      # green run always means the dashboard's history has today's scan in it.
+      - name: Scan MCP servers
+        run: npx -y ${cliSpec()} mcp-scan --project-only --trust-project --require-upload${issue ? " --github-issue" : ""} --fail-on ${failOn}
+        env:
+${env}
+`;
+}
+export {
+  MCP_SCAN_WORKFLOW_PATH,
+  renderMcpScanWorkflow,
+  secretNameFor
+};

package/dist/mcpStack-BYJCZNIV.js

@@ -0,0 +1,20 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  CROWDED_TOOL_COUNT,
+  TOKENS_PER_TOOL,
+  analyzeStack,
+  checkMcpStack,
+  isCrowded,
+  loadStackMembers
+} from "./chunk-VL2E5T2A.js";
+import "./chunk-6EQ3ARXA.js";
+import "./chunk-SHCEBP3J.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  CROWDED_TOOL_COUNT,
+  TOKENS_PER_TOOL,
+  analyzeStack,
+  checkMcpStack,
+  isCrowded,
+  loadStackMembers
+};

package/dist/packages-THVFMWFP.js

@@ -0,0 +1,42 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  ensureSeedEntry,
+  finishSyncRun,
+  getAllPackageNames,
+  getContributionsByOwner,
+  getPackageByName,
+  getPackageNamesCreatedSince,
+  getPackageVersions,
+  getSeedTargets,
+  getStaleRefreshTargets,
+  getTopPackageNames,
+  latestVersionsFor,
+  reusableFieldsFor,
+  stampFirstRequester,
+  startSyncRun,
+  upsertPackage,
+  upsertPackageVersions
+} from "./chunk-NH5I4KHH.js";
+import "./chunk-VLRHFMGJ.js";
+import "./chunk-LYMPYETA.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  ensureSeedEntry,
+  finishSyncRun,
+  getAllPackageNames,
+  getContributionsByOwner,
+  getPackageByName,
+  getPackageNamesCreatedSince,
+  getPackageVersions,
+  getSeedTargets,
+  getStaleRefreshTargets,
+  getTopPackageNames,
+  latestVersionsFor,
+  reusableFieldsFor,
+  stampFirstRequester,
+  startSyncRun,
+  upsertPackage,
+  upsertPackageVersions
+};

package/dist/plan-V4OEI3J4.js

@@ -0,0 +1,463 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  buildMermaid,
+  layerFor
+} from "./chunk-4F7ZESPO.js";
+import {
+  checkCompat,
+  latestDataAsOf,
+  recommend
+} from "./chunk-BULZAX2U.js";
+import "./chunk-QSL6QN5X.js";
+import "./chunk-M6NYEXCW.js";
+import "./chunk-6L3U7DZ5.js";
+import "./chunk-J5FZYN4A.js";
+import "./chunk-PSX3GIAN.js";
+import {
+  assembleMembers,
+  getOrFetchPackage,
+  inferCategory
+} from "./chunk-FW6BD2NO.js";
+import {
+  resolveArchitectureCompat
+} from "./chunk-BUALU27S.js";
+import "./chunk-LRD4GBYE.js";
+import "./chunk-BCANRN5B.js";
+import "./chunk-2VMOWSRY.js";
+import "./chunk-4ESO33J6.js";
+import {
+  getSandboxEdges
+} from "./chunk-CW5HJ3LX.js";
+import "./chunk-AHBP533R.js";
+import {
+  httpRequest
+} from "./chunk-SJOVFF7B.js";
+import "./chunk-HWBBVLOT.js";
+import "./chunk-NH5I4KHH.js";
+import {
+  DEFAULT_ECOSYSTEM,
+  isCategory
+} from "./chunk-VLRHFMGJ.js";
+import "./chunk-WQ23REYT.js";
+import {
+  packages
+} from "./chunk-LYMPYETA.js";
+import "./chunk-3GHJR7XR.js";
+import {
+  getConfig
+} from "./chunk-GRJXQBQZ.js";
+import "./chunk-WHX2ZFCG.js";
+import "./chunk-LUAKDHLZ.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import "./chunk-GPTKSNR6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/mcp/plan.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import { and, eq, inArray } from "drizzle-orm";
+
+// src/compat/optimize.ts
+init_esm_shims();
+function conflictsFor(members, sandboxConflicts) {
+  const out = resolveArchitectureCompat(members);
+  for (let i = 0; i < members.length; i++) {
+    for (let j = i + 1; j < members.length; j++) {
+      const a = members[i].name;
+      const b = members[j].name;
+      const key = a <= b ? `${a}|${b}` : `${b}|${a}`;
+      if (sandboxConflicts.has(key)) {
+        out.push({
+          source: "sandbox",
+          packages: [a, b],
+          detail: `${a} and ${b} are recorded as incompatible (sandbox)`
+        });
+      }
+    }
+  }
+  return out;
+}
+function optimizeStack(slots, sandboxConflicts = /* @__PURE__ */ new Set()) {
+  if (slots.some((s) => s.length === 0)) {
+    throw new Error("optimizeStack: every slot must have at least one candidate");
+  }
+  const n = slots.length;
+  const budget = 5e4;
+  let nodes = 0;
+  let exhausted = false;
+  let bestSelection = new Array(n).fill(0);
+  let bestRegret = conflictsFor(
+    slots.map((c) => c[0]).filter((m) => Boolean(m)),
+    sandboxConflicts
+  ).length === 0 ? 0 : Infinity;
+  const chosen = new Array(n).fill(0);
+  const dfs = (slot, regret) => {
+    if (nodes++ > budget) {
+      exhausted = true;
+      return;
+    }
+    if (regret >= bestRegret) return;
+    if (slot === n) {
+      bestSelection = chosen.slice();
+      bestRegret = regret;
+      return;
+    }
+    const candidates = slots[slot];
+    for (let i = 0; i < candidates.length; i++) {
+      chosen[slot] = i;
+      const assigned = chosen.slice(0, slot + 1).map((idx, s) => slots[s][idx]);
+      if (conflictsFor(assigned, sandboxConflicts).length === 0) {
+        dfs(slot + 1, regret + i);
+      }
+      if (nodes > budget) {
+        exhausted = true;
+        return;
+      }
+    }
+  };
+  dfs(0, 0);
+  const members = bestSelection.map((idx, s) => slots[s][idx]);
+  return {
+    selection: bestSelection,
+    conflicts: conflictsFor(members, sandboxConflicts),
+    regret: bestRegret === Infinity ? bestSelection.reduce((a, b) => a + b, 0) : bestRegret,
+    bounded: exhausted
+  };
+}
+
+// src/mcp/plan.ts
+function packageToCandidate(row) {
+  return {
+    name: row.name,
+    category: row.category,
+    healthScore: row.healthScore ?? 0,
+    qualityScore: row.qualityScore,
+    confidence: row.confidence ?? "unproven",
+    why: "pinned by you",
+    latestVersion: row.latestVersion,
+    weeklyDownloads: row.weeklyDownloads,
+    lastReleaseAt: row.lastReleaseAt ? row.lastReleaseAt.toISOString() : null,
+    repoUrl: row.repoUrl,
+    // A pin is the one slot lurq did not choose, which makes these MORE worth
+    // saying, not less: the user picked it, so nobody else is going to notice
+    // that it has been deprecated since they did.
+    deprecated: row.deprecated,
+    archived: row.archived,
+    advisories: row.advisories?.length ?? 0
+  };
+}
+async function resolvePins(db, using, recommendedNames, requestedByOwnerId = null) {
+  const slots = [];
+  const notFound = [];
+  const pending = [];
+  for (const name of new Set(using ?? [])) {
+    if (recommendedNames.has(name)) continue;
+    const { row, existsOnNpm } = await getOrFetchPackage(db, name, { requestedByOwnerId });
+    if (!row) {
+      (existsOnNpm ? pending : notFound).push(name);
+      continue;
+    }
+    slots.push({
+      need: `using ${name}`,
+      category: row.category,
+      layer: layerFor({ label: name, category: row.category }),
+      recommended: packageToCandidate(row),
+      alternatives: [],
+      // fixed: the user chose this, so it never gets swapped
+      note: "pinned by you"
+    });
+  }
+  return { slots, notFound, pending };
+}
+var PER_SLOT = 3;
+var MAX_SLOTS = 24;
+async function handlePlan(db, input, ownerId = null) {
+  const optimize = input.optimize ?? "balanced";
+  const decomposed = input.needs?.length ? { needs: dedupeNeeds(input.needs), source: "needs" } : input.document?.trim() ? await decompose(input.document) : null;
+  const hasPins = Boolean(input.using?.length);
+  if ((!decomposed || decomposed.needs.length === 0) && !hasPins) {
+    return {
+      note: "Provide a `document` (a detailed description of your program), a `needs` array, or a `using` list of packages you have already chosen. lurq recommends evidence-scored packages per component, it does not invent an architecture from a bare prompt."
+    };
+  }
+  const needs = (decomposed?.needs ?? []).slice(0, MAX_SLOTS);
+  const source = decomposed?.source ?? "needs";
+  let degradedReason = null;
+  const safeRecommend = (need, category) => recommend(db, {
+    need,
+    category,
+    limit: PER_SLOT,
+    onDegraded: (reason) => {
+      degradedReason ??= reason;
+    }
+  }).catch((err) => {
+    logger.warn(`plan: recommend failed for "${need}": ${err.message}`);
+    return [];
+  });
+  const effCat = (n) => n.category ?? inferCategory(n.need) ?? void 0;
+  const anchorFamily = familyOf(`${input.document ?? ""} ${needs.map((n) => n.need).join(" ")}`);
+  const metaIdx = needs.findIndex((n) => effCat(n) === "meta-framework");
+  const anchorIdx = metaIdx >= 0 ? metaIdx : needs.findIndex((n) => effCat(n) === "framework");
+  const recs = new Array(needs.length);
+  let framework = anchorFamily;
+  if (anchorIdx >= 0) {
+    recs[anchorIdx] = await safeRecommend(needs[anchorIdx].need, effCat(needs[anchorIdx]));
+    framework = recs[anchorIdx][0]?.name ?? anchorFamily;
+  }
+  const [, dataAsOf] = await Promise.all([
+    Promise.all(
+      needs.map(async (n, i) => {
+        if (i === anchorIdx) return;
+        const need = framework ? `${n.need} (for a ${framework} app)` : n.need;
+        recs[i] = await safeRecommend(need, effCat(n));
+      })
+    ),
+    latestDataAsOf(db)
+  ]);
+  const bundleByName = optimize === "speed" ? await bundleSizes(db, recs.flat()) : /* @__PURE__ */ new Map();
+  const taken = /* @__PURE__ */ new Set();
+  const recSlots = needs.map((n, i) => {
+    const candidates = orderCandidates(recs[i], anchorFamily, optimize, bundleByName);
+    const free = candidates.filter((c) => !taken.has(c.name));
+    const recommended = free[0] ?? null;
+    if (recommended) taken.add(recommended.name);
+    const category = n.category ?? recommended?.category ?? inferCategory(n.need);
+    return {
+      need: n.need,
+      category,
+      layer: layerFor({ label: recommended?.name ?? n.need, category }),
+      recommended,
+      alternatives: free.slice(1),
+      note: recommended ? void 0 : candidates.length ? "every match for this need is already in the stack for another slot" : "no tracked package matched this need yet"
+    };
+  });
+  const recommendedNames = new Set(
+    recSlots.map((s) => s.recommended?.name).filter((n) => Boolean(n))
+  );
+  const {
+    slots: pinnedSlots,
+    notFound: pinsNotFound,
+    pending: pinsPending
+  } = await resolvePins(db, input.using, recommendedNames, ownerId);
+  const slots = [...pinnedSlots, ...recSlots];
+  const compatibility = await resolveCompat(db, slots);
+  const unmatched = [
+    ...slots.filter((s) => !s.recommended).map((s) => s.need),
+    ...pinsNotFound.map((n) => `${n} (pinned, but not on the npm registry)`),
+    // A pin that exists and is merely being ingested is not an unmatched need —
+    // it just has no scores yet. Saying so keeps the user from "fixing" a name
+    // that was correct all along.
+    ...pinsPending.map((n) => `${n} (pinned; being scored now, retry shortly)`)
+  ];
+  const mermaid = buildMermaid(
+    slots.filter((s) => s.recommended).map((s) => ({ label: s.recommended.name, category: s.category }))
+  );
+  return {
+    dataAsOf,
+    optimize,
+    source,
+    framework,
+    slots,
+    unmatched,
+    mermaid,
+    note: planNote(source, unmatched.length, optimize, framework, degradedReason),
+    compatibility
+  };
+}
+function flagSlotConflicts(picks, conflicts) {
+  const out = /* @__PURE__ */ new Map();
+  for (const c of conflicts) {
+    for (const p of picks) {
+      if (p.name && c.packages.includes(p.name)) {
+        const others = c.packages.filter((n) => n !== p.name);
+        out.set(p.need, [.../* @__PURE__ */ new Set([...out.get(p.need) ?? [], ...others])]);
+      }
+    }
+  }
+  return out;
+}
+var NO_META = (c) => ({
+  name: c.name,
+  version: c.latestVersion,
+  peerDependencies: null,
+  peerDependenciesMeta: null,
+  engines: null
+});
+async function resolveCompat(db, slots) {
+  const eligible = slots.filter((s) => s.recommended);
+  if (eligible.length < 2) return null;
+  try {
+    const allNames = [
+      ...new Set(eligible.flatMap((s) => [s.recommended, ...s.alternatives].map((c) => c.name)))
+    ];
+    const [{ members }, edges] = await Promise.all([
+      assembleMembers(db, allNames),
+      getSandboxEdges(db, allNames)
+    ]);
+    const metaByName = new Map(members.map((m) => [m.name, m]));
+    const sandboxConflicts = new Set(
+      edges.filter((e) => e.status === "conflict").map((e) => `${e.packageA}|${e.packageB}`)
+    );
+    const slotCandidates = eligible.map(
+      (s) => [s.recommended, ...s.alternatives].map((c) => metaByName.get(c.name) ?? NO_META(c))
+    );
+    const { selection } = optimizeStack(slotCandidates, sandboxConflicts);
+    eligible.forEach((s, i) => {
+      const idx = selection[i] ?? 0;
+      if (idx <= 0) return;
+      const all = [s.recommended, ...s.alternatives];
+      const chosen = all[idx];
+      if (!chosen) return;
+      s.recommended = chosen;
+      s.alternatives = all.filter((c) => c.name !== chosen.name);
+      s.swappedFrom = all[0].name;
+    });
+  } catch (err) {
+    logger.warn(`plan: compat optimization failed: ${String(err)}`);
+  }
+  const compat = await checkCompat(
+    db,
+    eligible.map((s) => s.recommended.name)
+  ).catch(() => null);
+  if (compat) {
+    const flags = flagSlotConflicts(
+      slots.map((s) => ({ need: s.need, name: s.recommended?.name ?? null })),
+      compat.conflicts
+    );
+    for (const s of slots) {
+      const cw = flags.get(s.need);
+      s.conflictsWith = cw?.length ? cw : void 0;
+    }
+  }
+  return compat;
+}
+function planNote(source, unmatched, optimize, framework, degraded) {
+  const base = source === "heuristic" ? "Components were extracted from your document with a keyword heuristic (no summary LLM configured), coarse; pass a `needs` array or set SUMMARY_API_KEY for sharper decomposition." : source === "llm" ? "Components were extracted from your document by the summary model." : "Components taken from the supplied needs.";
+  const grounding = " Each package is recommended from lurq\u2019s scored index, a labeled, evidence-backed starting point, not a validated architecture.";
+  const ctx = framework ? ` Anchored to the ${framework} ecosystem so sibling libraries stay coherent across the stack.` : "";
+  const tail = unmatched ? ` ${unmatched} need(s) had no tracked match (listed in \`unmatched\`).` : "";
+  const opt = optimize === "speed" ? " Ranking favored the lightest-bundle option per slot." : "";
+  const degradedWarning = degraded ? `DEGRADED: semantic search was unavailable (${degraded}), so these picks come from keyword matching alone and are materially less reliable than usual. Treat them as a shortlist to verify, and re-run when search recovers. ` : "";
+  return degradedWarning + base + grounding + ctx + opt + tail;
+}
+function dedupeNeeds(needs) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const n of needs) {
+    const key = n.need.trim().toLowerCase();
+    if (!key) continue;
+    if (!seen.has(key)) seen.set(key, { need: n.need.trim(), category: n.category });
+  }
+  return [...seen.values()];
+}
+var FAMILY_TOKENS = [
+  { family: "react", re: /\breact\b|preact/ },
+  { family: "vue", re: /\bvue\b|nuxt/ },
+  { family: "angular", re: /angular/ },
+  { family: "svelte", re: /svelte/ },
+  { family: "solid", re: /\bsolid(-?js)?\b/ }
+];
+function familyOf(name) {
+  const n = name.toLowerCase();
+  for (const f of FAMILY_TOKENS) if (f.re.test(n)) return f.family;
+  return null;
+}
+function orderCandidates(cands, anchorFamily, optimize, bundleByName) {
+  const coherence = (c) => {
+    const fam = familyOf(c.name);
+    if (!fam) return 0;
+    return fam === anchorFamily ? 1 : -1;
+  };
+  return [...cands].sort((a, b) => {
+    if (anchorFamily) {
+      const d = coherence(b) - coherence(a);
+      if (d) return d;
+    }
+    if (optimize === "speed") {
+      return (bundleByName.get(a.name) ?? Infinity) - (bundleByName.get(b.name) ?? Infinity);
+    }
+    return 0;
+  });
+}
+async function bundleSizes(db, candidates) {
+  const names = [...new Set(candidates.map((c) => c.name))];
+  if (names.length === 0) return /* @__PURE__ */ new Map();
+  const rows = await db.select({ name: packages.name, bundle: packages.bundleMinGzipKb }).from(packages).where(and(inArray(packages.name, names), eq(packages.ecosystem, DEFAULT_ECOSYSTEM)));
+  return new Map(rows.filter((r) => r.bundle != null).map((r) => [r.name, r.bundle]));
+}
+async function decompose(document) {
+  const config = getConfig();
+  if (config.SUMMARY_PROVIDER === "openai" && config.SUMMARY_API_KEY) {
+    const llm = await decomposeWithLlm(
+      document,
+      config.SUMMARY_API_KEY,
+      config.SUMMARY_MODEL,
+      config.SUMMARY_BASE_URL
+    ).catch((err) => {
+      logger.warn(`plan: LLM decomposition failed, using heuristic: ${err.message}`);
+      return null;
+    });
+    if (llm?.length) return { needs: dedupeNeeds(llm), source: "llm" };
+  }
+  return { needs: decomposeHeuristic(document), source: "heuristic" };
+}
+var DECOMPOSE_SYSTEM = "You break a software project description into the distinct technical components that each need a library. Return ONLY components the project actually requires, grounded in the description. Respond with a JSON object.";
+async function decomposeWithLlm(document, apiKey, model, baseUrl) {
+  const prompt = [
+    "Project description:",
+    document.slice(0, 8e3),
+    "",
+    'Return JSON: { "needs": [ { "need": "<one phrase describing a component that needs a library>", "category": "<optional taxonomy hint or empty>" } ] }.',
+    "One entry per distinct component (e.g. routing, validation, ORM, HTTP client). Omit anything not implied by the description."
+  ].join("\n");
+  const { data } = await httpRequest(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
+    host: new URL(baseUrl).host,
+    method: "POST",
+    ttlMs: 24 * 60 * 60 * 1e3,
+    // Hash the FULL document — length + a 64-char prefix collide for same-length
+    // edits or shared templated headers, which would serve a stale decomposition.
+    cacheKey: `openai-plan ${model} ${createHash("sha1").update(document).digest("hex")}`,
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: "system", content: DECOMPOSE_SYSTEM },
+        { role: "user", content: prompt }
+      ],
+      response_format: { type: "json_object" },
+      temperature: 0.2
+    })
+  });
+  const content = data?.choices?.[0]?.message?.content;
+  const parsed = content ? JSON.parse(content) : {};
+  const raw = Array.isArray(parsed?.needs) ? parsed.needs : [];
+  return raw.map((n) => {
+    const need = typeof n?.need === "string" ? n.need.trim() : "";
+    if (!need) return null;
+    const cat = typeof n?.category === "string" && isCategory(n.category) ? n.category : void 0;
+    return { need, category: cat };
+  }).filter(Boolean);
+}
+function decomposeHeuristic(document) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const rawLine of document.split("\n")) {
+    const line = rawLine.replace(/^[#>*\-\s]+/, "").replace(/^\d+\.\s+/, "").trim();
+    if (line.length < 3) continue;
+    const category = inferCategory(line);
+    if (category && !byCategory.has(category)) {
+      byCategory.set(category, line.slice(0, 120));
+    }
+  }
+  return [...byCategory.entries()].map(([category, need]) => ({ need, category }));
+}
+export {
+  decomposeHeuristic,
+  familyOf,
+  flagSlotConflicts,
+  handlePlan,
+  orderCandidates,
+  resolvePins
+};

package/dist/planView-JRXGCG2N.js

@@ -0,0 +1,79 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/planView.ts
+init_esm_shims();
+function esc(s) {
+  return s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+}
+function slotRows(plan) {
+  return plan.slots.map((s) => {
+    const rec = s.recommended;
+    const name = rec ? rec.repoUrl ? `<a href="${esc(rec.repoUrl)}" target="_blank" rel="noreferrer">${esc(rec.name)}</a>` : esc(rec.name) : '<span class="muted">no match</span>';
+    const alts = s.alternatives.map((a) => esc(a.name)).join(", ") || '<span class="muted">-</span>';
+    return `<tr>
+        <td>${esc(s.need)}</td>
+        <td><span class="layer">${esc(s.layer)}</span></td>
+        <td class="pkg">${name}</td>
+        <td class="num">${rec ? rec.healthScore : "-"}</td>
+        <td>${rec ? esc(rec.confidence) : "-"}</td>
+        <td class="alts">${alts}</td>
+      </tr>`;
+  }).join("\n");
+}
+function renderPlanHtml(plan) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>lurq plan: roadmap</title>
+<style>
+  :root { color-scheme: dark; }
+  * { box-sizing: border-box; }
+  body { margin: 0; font: 15px/1.5 ui-sans-serif, system-ui, -apple-system, sans-serif;
+         background: #0b0b0f; color: #e7e7ea; padding: 2.5rem clamp(1rem, 5vw, 4rem); }
+  h1 { font-size: 1.5rem; margin: 0 0 .25rem; }
+  h2 { font-size: 1rem; text-transform: uppercase; letter-spacing: .08em; color: #9a9aa6; margin: 2.5rem 0 .75rem; }
+  .sub { color: #9a9aa6; margin: 0 0 1rem; max-width: 70ch; }
+  .diagram { background: #141419; border: 1px solid #26262e; border-radius: 14px; padding: 1.5rem; overflow: auto; }
+  table { width: 100%; border-collapse: collapse; margin-top: .5rem; }
+  th, td { text-align: left; padding: .55rem .75rem; border-bottom: 1px solid #1e1e25; vertical-align: top; }
+  th { font-size: .78rem; text-transform: uppercase; letter-spacing: .05em; color: #9a9aa6; }
+  .pkg a { color: #d98cff; text-decoration: none; } .pkg a:hover { text-decoration: underline; }
+  .num { text-align: right; font-variant-numeric: tabular-nums; }
+  .muted { color: #6a6a76; } .alts { color: #b8b8c2; font-size: .92rem; }
+  .layer { font-size: .8rem; color: #8ad; background: #15202b; border-radius: 6px; padding: .1rem .45rem; }
+  footer { margin-top: 2.5rem; color: #6a6a76; font-size: .85rem; }
+</style>
+</head>
+<body>
+  <h1>lurq plan <span class="muted">\xB7 ${esc(plan.optimize)} \xB7 ${esc(plan.source)}${plan.framework ? ` \xB7 ${esc(plan.framework)} ecosystem` : ""}</span></h1>
+  <p class="sub">${esc(plan.note)}</p>
+
+  <h2>Roadmap</h2>
+  <div class="diagram"><pre class="mermaid">${esc(plan.mermaid)}</pre></div>
+
+  <h2>Components</h2>
+  <table>
+    <thead><tr><th>Component</th><th>Layer</th><th>Recommended</th><th>Health</th><th>Confidence</th><th>Alternatives</th></tr></thead>
+    <tbody>
+${slotRows(plan)}
+    </tbody>
+  </table>
+
+  <footer>data as of ${esc(plan.dataAsOf)} \xB7 generated by lurq</footer>
+
+  <script type="module">
+    import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
+    mermaid.initialize({ startOnLoad: true, theme: 'dark' });
+  </script>
+</body>
+</html>
+`;
+}
+export {
+  renderPlanHtml
+};