lurqrun 0.1.6 → 0.1.8

package/dist/fix-3EDWNKW3.js

@@ -0,0 +1,220 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  SCAN_LIMIT,
+  fixableTargets,
+  parseUpgradeSpec,
+  planUpgrades
+} from "./chunk-QCRBX3LV.js";
+import {
+  manifestFindings
+} from "./chunk-5ALIJFDA.js";
+import {
+  applyEdits,
+  deterministic,
+  editsByFile,
+  unifiedDiff
+} from "./chunk-BM3LF5T6.js";
+import "./chunk-3GHJR7XR.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/fix.ts
+init_esm_shims();
+import { readFileSync, writeFileSync } from "fs";
+import { join, relative } from "path";
+async function derivePlanTargets(dir, opts) {
+  const { buildUpgradePlan } = await import("./upgradePlan-ZS5IOVMZ.js");
+  try {
+    const plan = await buildUpgradePlan(dir, {
+      url: opts.url,
+      apiKey: opts.apiKey,
+      repo: opts.repo
+    });
+    return fixableTargets(plan.upgrades, opts.max);
+  } catch (err) {
+    if (err instanceof Error && err.name === "MissingKeyError") {
+      throw new Error(
+        `${err.message}
+
+Or skip the lookup: \`lurq fix --upgrade pkg@from..to\` reads both versions straight from npm and needs no key.`
+      );
+    }
+    throw err;
+  }
+}
+function stage(root, findings) {
+  const writes = /* @__PURE__ */ new Map();
+  let diff = "";
+  for (const [file, edits] of editsByFile(findings.filter(deterministic))) {
+    const before = readFileSync(join(root, file), "utf8");
+    diff += unifiedDiff(file, before, edits);
+    writes.set(file, applyEdits(before, edits));
+  }
+  return { writes, diff };
+}
+async function runFix(dir, opts) {
+  const { scanReferences } = await import("./references-I6Y4BSRR.js");
+  const { checkUpgrade } = await import("./upgrade-FS26DJGG.js");
+  const { renamePlan } = await import("./rename-OS6JYBZQ.js");
+  const asked = Boolean(opts.plan) || (opts.upgrade?.length ?? 0) > 0;
+  const split = asked ? {
+    ...fixableTargets(opts.plan ? planUpgrades(opts.plan) : [], opts.max),
+    named: (opts.upgrade ?? []).map(parseUpgradeSpec)
+  } : { ...await derivePlanTargets(dir, opts), named: [] };
+  const targets = [...split.targets, ...split.named];
+  const skipped = split.skipped;
+  const { runDomains, SOURCE_DOMAINS } = await import("./domains-VRT4BRVZ.js");
+  const source = await runDomains({ dir, domains: SOURCE_DOMAINS });
+  const unchecked = source.skipped.map((d) => ({ domain: d.domain, reason: d.reason }));
+  if (targets.length === 0 && source.findings.length === 0) {
+    const empty = {
+      root: dir,
+      files: [],
+      applied: [],
+      remaining: [],
+      refused: [],
+      skipped,
+      unchecked
+    };
+    const lines = skipped.length ? [
+      `Nothing attempted in ${dir}. ${skipped.length} upgrade(s) deliberately not tried:`,
+      ...skippedLines(skipped)
+    ] : [
+      `Nothing to fix in ${dir}: ${asked ? "no upgrade named here needs a change" : "every dependency is current or held by the repo policy"}, ${// Never "the source is clean" when no detector survived to look.
+      // `ran` is empty only when every source domain threw, and that is
+      // the one case where the reassuring sentence would be false.
+      source.ran.length ? "and nothing in the source needs changing" : "and the source could not be scanned"}.`
+    ];
+    lines.push(...uncheckedLines(unchecked));
+    console.log(opts.json ? JSON.stringify(empty, null, 2) : lines.join("\n"));
+    return;
+  }
+  let findings = [];
+  const refused = [];
+  if (targets.length > 0) {
+    const refs = scanReferences(dir, { limit: SCAN_LIMIT });
+    const report = await checkUpgrade(targets, refs, { rootDir: dir });
+    const renames = renamePlan(report);
+    const { findManifests } = await import("./upgradePlan-ZS5IOVMZ.js");
+    const manifests = manifestFindings(dir, targets, {
+      files: findManifests(dir).map((abs) => relative(dir, abs) || "package.json")
+    });
+    findings = [...renames.findings, ...manifests.findings];
+    refused.push(
+      ...renames.refused,
+      ...manifests.refused.map((r) => ({ symbol: r.package, file: r.file, reason: r.reason }))
+    );
+  }
+  findings = [...findings, ...source.findings];
+  const result = {
+    root: dir,
+    files: [],
+    applied: [],
+    remaining: [],
+    refused: refused.map((r) => ({ symbol: r.symbol, file: r.file, reason: r.reason })),
+    skipped,
+    unchecked
+  };
+  const { writes, diff } = stage(dir, findings);
+  result.files = [...writes.keys()];
+  for (const f of findings) {
+    if (deterministic(f)) {
+      result.applied.push({
+        code: f.code,
+        summary: f.fix.summary,
+        files: [...new Set(f.fix.edits.map((e) => e.file))]
+      });
+    } else {
+      result.remaining.push({
+        code: f.code,
+        detail: f.detail,
+        instruction: f.fix?.task?.instruction,
+        files: f.fix?.task?.files,
+        evidence: f.fix?.task?.evidence
+      });
+    }
+  }
+  if (opts.apply && writes.size > 0) {
+    const { writeFileAtomic } = await import("./installSkill-5TIMYIJZ.js");
+    for (const [file, contents] of writes) writeFileAtomic(join(dir, file), contents);
+  }
+  if (opts.sarif) {
+    const { toSarif } = await import("./sarif-WLVJFJ7U.js");
+    const { VERSION } = await import("./constants-DJFOFZ44.js");
+    const sarif = toSarif(findings, {
+      version: VERSION,
+      // Read from disk rather than reusing the staged text: regions must
+      // describe the file as it is, not as it would be after the fix.
+      read: (file) => {
+        try {
+          return readFileSync(join(dir, file), "utf8");
+        } catch {
+          return null;
+        }
+      }
+    });
+    writeFileSync(opts.sarif, `${JSON.stringify(sarif, null, 2)}
+`, "utf8");
+    console.error(`wrote ${opts.sarif}`);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ ...result, applied_to_disk: Boolean(opts.apply) }, null, 2));
+  } else {
+    console.log(formatFix(result, diff, Boolean(opts.apply)));
+  }
+  if (opts.exitCode && result.remaining.length > 0) process.exitCode = 1;
+}
+function uncheckedLines(unchecked) {
+  if (unchecked.length === 0) return [];
+  return [
+    "",
+    `${unchecked.length} domain(s) could not be checked:`,
+    ...unchecked.map((u) => `  ${u.domain}: ${u.reason}`)
+  ];
+}
+function skippedLines(skipped) {
+  return skipped.map((s) => `  ${s.package}: ${s.reason}`);
+}
+function formatFix(result, diff, applied) {
+  const out = [];
+  if (result.applied.length === 0 && result.remaining.length === 0) {
+    return [
+      `Nothing to fix in ${result.root}: no upgrade in this plan renames a symbol this code references,`,
+      "every declared range already admits its target, and nothing in the source names a retired model",
+      "or reads an undeclared variable."
+    ].join(" ");
+  }
+  if (result.applied.length > 0) {
+    out.push(
+      applied ? `Wrote ${result.files.length} file(s) in ${result.root}:` : `Would write ${result.files.length} file(s) in ${result.root} (pass --apply):`
+    );
+    for (const a of result.applied) out.push(`  ${a.summary} \u2014 ${a.files.join(", ")}`);
+    if (!applied && diff) out.push("", diff.trimEnd());
+  }
+  if (result.remaining.length > 0) {
+    out.push("", `${result.remaining.length} change(s) lurq will not make for you:`);
+    for (const r of result.remaining) {
+      out.push(`  ${r.detail}`);
+      if (r.instruction) out.push(`    do: ${r.instruction}`);
+      if (r.files?.length) out.push(`    in: ${r.files.join(", ")}`);
+      for (const e of r.evidence ?? []) out.push(`    use: ${e}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    out.push("", `${result.skipped.length} upgrade(s) deliberately not attempted:`);
+    out.push(...skippedLines(result.skipped));
+  }
+  out.push(...uncheckedLines(result.unchecked));
+  if (result.refused.length > 0) {
+    out.push("", "Proven renames left alone:");
+    for (const r of result.refused) out.push(`  ${r.file ?? r.symbol}: ${r.reason}`);
+  }
+  return out.join("\n");
+}
+export {
+  formatFix,
+  runFix,
+  stage,
+  uncheckedLines
+};

package/dist/handlers-4Q37WIFT.js

@@ -0,0 +1,55 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  USAGE_PAGE_SIZE,
+  handleCompare,
+  handleCompat,
+  handleEvaluate,
+  handlePolicy,
+  handleRecommend,
+  handleReportOutcome,
+  handleUsage,
+  handleVerify,
+  latestDataAsOf,
+  rowToEvaluate
+} from "./chunk-64ZF7KO4.js";
+import "./chunk-QSL6QN5X.js";
+import "./chunk-NYZU5NCW.js";
+import "./chunk-2WD4QAH4.js";
+import "./chunk-DSROTZ3Z.js";
+import "./chunk-TUXQ32WE.js";
+import "./chunk-BUALU27S.js";
+import "./chunk-QUIMQ7YL.js";
+import "./chunk-6DM6UQFD.js";
+import "./chunk-EYAKM6YN.js";
+import "./chunk-D3VTZS7V.js";
+import "./chunk-4ESO33J6.js";
+import "./chunk-NPVN2THM.js";
+import "./chunk-VLRHFMGJ.js";
+import "./chunk-VGCDRK3S.js";
+import "./chunk-4JHDSVIN.js";
+import "./chunk-GM5Y555O.js";
+import "./chunk-2GAYNIHG.js";
+import "./chunk-KYKSZ3XZ.js";
+import "./chunk-A3TYI2TF.js";
+import "./chunk-HWFX4BC4.js";
+import "./chunk-6L67QMCP.js";
+import "./chunk-3GHJR7XR.js";
+import "./chunk-GRJXQBQZ.js";
+import "./chunk-WHX2ZFCG.js";
+import "./chunk-LUAKDHLZ.js";
+import "./chunk-MYGSLK44.js";
+import "./chunk-72Y2FDVS.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  USAGE_PAGE_SIZE,
+  handleCompare,
+  handleCompat,
+  handleEvaluate,
+  handlePolicy,
+  handleRecommend,
+  handleReportOutcome,
+  handleUsage,
+  handleVerify,
+  latestDataAsOf,
+  rowToEvaluate
+};

package/dist/hook-NA66XJLC.js

@@ -0,0 +1,412 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/hook.ts
+init_esm_shims();
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, isAbsolute, join } from "path";
+
+// src/benchmark/normalize.ts
+init_esm_shims();
+var NPM_NAME_RE = /^(@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+function isValidNpmName(name) {
+  if (!name || name.length > 214) return false;
+  return NPM_NAME_RE.test(name);
+}
+
+// src/cli/hook.ts
+var MANAGERS = /* @__PURE__ */ new Map([
+  ["npm", /* @__PURE__ */ new Set(["install", "i", "in", "add"])],
+  ["pnpm", /* @__PURE__ */ new Set(["add", "install", "i"])],
+  ["yarn", /* @__PURE__ */ new Set(["add"])],
+  ["bun", /* @__PURE__ */ new Set(["add", "install", "i"])]
+]);
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--prefix",
+  "--registry",
+  "--filter",
+  "-F",
+  "-C",
+  "--dir",
+  "--cwd",
+  "--workspace",
+  "-w",
+  "--tag",
+  "--cache",
+  "--userconfig"
+]);
+var MAX_NAMES = 10;
+var VERIFY_TIMEOUT_MS = 8e3;
+function specName(spec) {
+  if (/[:/\\]/.test(spec.replace(/^@[^/]+\//, "")) || /\.(tgz|tar|tar\.gz)$/.test(spec))
+    return null;
+  const at = spec.indexOf("@", 1);
+  const name = at === -1 ? spec : spec.slice(0, at);
+  return isValidNpmName(name) ? name : null;
+}
+var ALLOW_ENV = "LURQ_ALLOW=1";
+function commandStart(tokens) {
+  let i = 0;
+  while (i < tokens.length && (tokens[i] === "sudo" || /^[A-Za-z_]\w*=/.test(tokens[i]))) {
+    if (tokens[i] === ALLOW_ENV) return -1;
+    i++;
+  }
+  return i;
+}
+function installTargets(command) {
+  const names = /* @__PURE__ */ new Set();
+  for (const segment of command.split(/&&|\|\||[;|\n]/)) {
+    const tokens = segment.trim().split(/\s+/);
+    const i = commandStart(tokens);
+    if (i === -1) continue;
+    if (!MANAGERS.get(tokens[i] ?? "")?.has(tokens[i + 1] ?? "")) continue;
+    for (let j = i + 2; j < tokens.length; j++) {
+      const t = tokens[j];
+      if (VALUE_FLAGS.has(t)) j++;
+      else if (!t.startsWith("-")) {
+        const name = specName(t);
+        if (name) names.add(name);
+      }
+    }
+  }
+  return [...names];
+}
+var RUNNERS = [
+  ["npx", null],
+  ["bunx", null],
+  ["pnpm", "dlx"],
+  ["yarn", "dlx"]
+];
+function runTargets(command, hasLocalBin = () => false) {
+  const names = /* @__PURE__ */ new Set();
+  for (const segment of command.split(/&&|\|\||[;|\n]/)) {
+    const tokens = segment.trim().split(/\s+/);
+    const i = commandStart(tokens);
+    if (i === -1) continue;
+    const runner = RUNNERS.find(
+      ([bin, verb]) => tokens[i] === bin && (verb === null || tokens[i + 1] === verb)
+    );
+    if (!runner) continue;
+    for (let j = i + (runner[1] ? 2 : 1); j < tokens.length; j++) {
+      const t = tokens[j];
+      if (t === "-p" || t === "--package") {
+        const name = specName(tokens[++j] ?? "");
+        if (name) names.add(name);
+      } else if (t.startsWith("--package=")) {
+        const name = specName(t.slice("--package=".length));
+        if (name) names.add(name);
+      } else if (!t.startsWith("-")) {
+        const name = specName(t);
+        if (name && !hasLocalBin(name)) names.add(name);
+        break;
+      }
+    }
+  }
+  return [...names];
+}
+var DEP_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function addedDependencies(before, after) {
+  const read = (text) => {
+    try {
+      const v = JSON.parse(text);
+      return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+    } catch {
+      return null;
+    }
+  };
+  const [was, now] = [read(before || "{}"), read(after)];
+  if (!was || !now) return null;
+  const had = new Set(DEP_FIELDS.flatMap((f) => Object.keys(was[f] ?? {})));
+  const added = /* @__PURE__ */ new Set();
+  for (const field of DEP_FIELDS) {
+    for (const [name, range] of Object.entries(now[field] ?? {})) {
+      if (had.has(name) || typeof range !== "string" || /[:/]/.test(range)) continue;
+      if (specName(name) === name) added.add(name);
+    }
+  }
+  return [...added];
+}
+var clip = (s, n = 240) => {
+  const line = s.replace(/\s+/g, " ").trim();
+  return line.length > n ? `${line.slice(0, n - 1)}\u2026` : line;
+};
+function decide(checked, opts = {}) {
+  const list = (xs) => xs.map((x) => x.name).join(", ");
+  const why = (xs) => xs.map((x) => `${x.name}: ${clip(x.verdict.reasons[0] ?? x.verdict.scope)}`).join("; ");
+  const invalid = opts.deny === false ? [] : checked.filter((c) => c.verdict.level === "invalid");
+  if (invalid.length) {
+    return {
+      permissionDecision: "deny",
+      permissionDecisionReason: `lurq: ${list(invalid)} ${invalid.length === 1 ? "is not a real npm package" : "are not real npm packages"}, so this was stopped before it ran. Check the name for a typo or a package that never existed, and tell the user what lurq found. (${why(invalid)})`
+    };
+  }
+  const high = checked.filter((c) => c.verdict.level === "high");
+  if (high.length) {
+    return {
+      permissionDecision: "ask",
+      permissionDecisionReason: `lurq flags ${list(high)} as high risk: ${why(high)}. Run \`lurq verify <package>\` for the evidence.`
+    };
+  }
+  return null;
+}
+function unseen(sessionId, keys, dir = join(tmpdir(), "lurq-hooks")) {
+  if (typeof sessionId !== "string" || !sessionId || keys.length === 0) return [];
+  const path = join(dir, `${sessionId.replace(/[^\w-]/g, "").slice(0, 80)}.json`);
+  let seen = [];
+  try {
+    seen = JSON.parse(readFileSync(path, "utf8")).seen ?? [];
+  } catch {
+  }
+  const fresh = [...new Set(keys)].filter((k) => !seen.includes(k));
+  if (fresh.length) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify({ seen: [...seen, ...fresh] }));
+  }
+  return fresh;
+}
+function isJsProject(cwd) {
+  if (typeof cwd !== "string" || !cwd) return false;
+  for (let dir = cwd; ; dir = dirname(dir)) {
+    if (existsSync(join(dir, "package.json"))) return true;
+    if (dirname(dir) === dir) return false;
+  }
+}
+var PROMPT_TIPS = [
+  {
+    kind: "choose",
+    test: /\b(which|best|recommend\w*|alternatives?|librar(y|ies)|sdks?|frameworks?)\b/i,
+    tip: "lurq is connected. If this means choosing a library, name the candidates you know and check them with lurq compare (evaluate for one), then verify the pick: your sense of package health is from training, lurq is current."
+  },
+  {
+    kind: "upgrade",
+    test: /\b(upgrad\w*|bump\w*|migrat\w*|deprecat\w*|breaking|major version|latest version)\b/i,
+    tip: "lurq is connected. For an upgrade, call lurq diff_surface with the package and both versions to see what was removed or changed, and compat for the resulting set, before editing code."
+  },
+  {
+    kind: "install",
+    test: /\b(install\w*|dependenc(y|ies)|add (a |an |the )?(package|library|dep))\b/i,
+    tip: "lurq is connected. Call lurq verify before adding a package and usage before writing code against one. Installs in this session are also checked automatically."
+  }
+];
+function promptTips(prompt2) {
+  return PROMPT_TIPS.filter((t) => t.test.test(prompt2)).map(({ kind, tip }) => ({ kind, tip }));
+}
+function applyEdits(text, edits) {
+  let out = text;
+  for (const e of edits) {
+    if (typeof e.old_string !== "string" || typeof e.new_string !== "string" || !out.includes(e.old_string))
+      return null;
+    out = e.replace_all ? out.split(e.old_string).join(e.new_string) : out.replace(e.old_string, () => e.new_string);
+  }
+  return out;
+}
+var readIfExists = (path) => existsSync(path) ? readFileSync(path, "utf8") : "";
+function patchedPackageJsons(patch, cwd, read = readIfExists) {
+  const files = [];
+  for (const section of patch.split(/^\*\*\* (?=(?:Add|Update|Delete) File: )/m).slice(1)) {
+    const [header = "", ...rest] = section.split("\n");
+    const m = /^(Add|Update) File: (.+)$/.exec(header.trim());
+    if (!m || basename(m[2]) !== "package.json") continue;
+    const body = rest.filter((l) => !l.startsWith("*** "));
+    if (m[1] === "Add") {
+      files.push({
+        before: "",
+        after: body.filter((l) => l.startsWith("+")).map((l) => l.slice(1)).join("\n")
+      });
+      continue;
+    }
+    const before = read(isAbsolute(m[2]) ? m[2] : join(cwd, m[2]));
+    const edits = body.join("\n").split(/^@@.*$/m).map((h) => h.split("\n").filter((l) => /^[ +-]/.test(l))).filter((h) => h.length > 0).map((h) => ({
+      old_string: h.filter((l) => !l.startsWith("+")).map((l) => l.slice(1)).join("\n"),
+      new_string: h.filter((l) => !l.startsWith("-")).map((l) => l.slice(1)).join("\n")
+    }));
+    const after = applyEdits(before, edits);
+    if (after !== null) files.push({ before, after });
+  }
+  return files;
+}
+function targets(tool, input, cwd) {
+  const none = { installs: [], runs: [] };
+  if (typeof input.command === "string" && tool === "Bash") {
+    return {
+      installs: installTargets(input.command),
+      runs: runTargets(input.command, (n) => existsSync(join(cwd, "node_modules", ".bin", n)))
+    };
+  }
+  if (typeof input.command === "string" && tool === "apply_patch") {
+    const installs = patchedPackageJsons(input.command, cwd).flatMap(
+      (f) => addedDependencies(f.before, f.after) ?? []
+    );
+    return { installs: [...new Set(installs)], runs: [] };
+  }
+  if (typeof input.file_path !== "string" || basename(input.file_path) !== "package.json")
+    return none;
+  const before = readIfExists(input.file_path);
+  const after = tool === "Write" ? typeof input.content === "string" ? input.content : null : tool === "Edit" ? applyEdits(before, [input]) : tool === "MultiEdit" && Array.isArray(input.edits) ? applyEdits(before, input.edits) : null;
+  return { installs: after === null ? [] : addedDependencies(before, after) ?? [], runs: [] };
+}
+var usageNudge = (names) => `Before writing code against ${names.join(", ")}, call lurq usage with ${names.length === 1 ? "it" : "each"} (with knownVersion if you remember one): APIs move, and what you remember is from training.`;
+function freshUsage(sessionId, names) {
+  return unseen(
+    sessionId,
+    names.map((n) => `usage:${n}`)
+  ).map((k) => k.slice("usage:".length));
+}
+async function preToolUse(input, nudge) {
+  const cwd = typeof input.cwd === "string" ? input.cwd : process.cwd();
+  const { installs, runs } = targets(input.tool_name, input.tool_input ?? {}, cwd);
+  const names = [.../* @__PURE__ */ new Set([...installs, ...runs])].slice(0, MAX_NAMES);
+  if (names.length === 0) return null;
+  const { callTool } = await import("./remote-FN6225AH.js");
+  const settled = await Promise.allSettled(
+    names.map(
+      (name) => callTool(
+        "verify",
+        { package: name },
+        { timeoutMs: VERIFY_TIMEOUT_MS }
+      ).then((r) => ({ name, verdict: r.verdict }))
+    )
+  );
+  const checked = settled.flatMap(
+    (s) => s.status === "fulfilled" && s.value.verdict ? [{ name: s.value.name, verdict: s.value.verdict }] : []
+  );
+  const installed = checked.filter((c) => installs.includes(c.name));
+  const decision = decide(installed) ?? decide(
+    checked.filter((c) => !installs.includes(c.name)),
+    { deny: false }
+  );
+  if (decision) return { decision };
+  if (!nudge) return null;
+  const clean = installed.filter((c) => c.verdict.level !== "invalid" && c.verdict.level !== "high").map((c) => c.name);
+  const fresh = freshUsage(input.session_id, clean);
+  return fresh.length ? { context: `lurq verified ${fresh.join(", ")} before this ran. ${usageNudge(fresh)}` } : null;
+}
+function postToolUse(input) {
+  const command = input.tool_input?.command;
+  if (typeof command !== "string") return null;
+  const fresh = freshUsage(input.session_id, installTargets(command));
+  return fresh.length ? { context: `lurq checked ${fresh.join(", ")} before install. ${usageNudge(fresh)}` } : null;
+}
+var brief = (agent) => `lurq is connected to this session: package installs${agent === "cursor" ? "" : " and package.json dependency edits"} are verified automatically. Call lurq usage before writing code against a package API you know from training, and compare or evaluate when choosing a package.`;
+var SCAN_TIMEOUT_MS = 5e3;
+async function sessionDrift(input) {
+  const cwd = input.cwd;
+  if (typeof cwd !== "string" || !isJsProject(cwd)) return null;
+  if (unseen(input.session_id, [`scan:${cwd}`]).length === 0) return null;
+  try {
+    const { buildUpgradePlan, planHeadline, scanSourceDrift } = await import("./upgradePlan-ZS5IOVMZ.js");
+    const [plan, source] = await Promise.all([
+      buildUpgradePlan(cwd, { timeoutMs: SCAN_TIMEOUT_MS }),
+      scanSourceDrift(cwd)
+    ]);
+    const headline = planHeadline(plan, source);
+    return headline && `lurq scanned this project: ${headline}`;
+  } catch {
+    return null;
+  }
+}
+async function sessionStart(input, agent) {
+  const { apiKey, getAlerts } = await import("./remote-FN6225AH.js");
+  apiKey();
+  const [alerts, drift] = await Promise.all([
+    getAlerts({ timeoutMs: 3e3, agent: agent === "claude" ? "claude-code" : agent }).catch(
+      () => null
+    ),
+    sessionDrift(input)
+  ]);
+  const text = [isJsProject(input.cwd) ? brief(agent) : null, drift, alerts].filter(Boolean).join("\n\n");
+  return text ? { context: text } : null;
+}
+function prompt(input) {
+  if (typeof input.prompt !== "string" || !isJsProject(input.cwd)) return null;
+  const tips = promptTips(input.prompt);
+  const fresh = new Set(
+    unseen(
+      input.session_id,
+      tips.map((t) => t.kind)
+    )
+  );
+  const text = tips.filter((t) => fresh.has(t.kind)).map((t) => t.tip).join("\n");
+  return text ? { context: text } : null;
+}
+var HOOK_AGENTS = ["claude", "codex", "cursor"];
+function normalize(agent, input) {
+  if (agent !== "cursor") return input;
+  const command = typeof input.command === "string" ? input.command : input.tool_input?.command;
+  return {
+    session_id: input.conversation_id ?? input.session_id,
+    cwd: input.cwd ?? input.workspace_roots?.[0],
+    ...typeof command === "string" ? { tool_name: "Bash", tool_input: { command } } : {}
+  };
+}
+var CLAUDE_EVENT = {
+  "session-start": "SessionStart",
+  prompt: "UserPromptSubmit",
+  "pre-tool-use": "PreToolUse"
+};
+function render(agent, event, outcome) {
+  if (!outcome) return null;
+  const { decision, context } = outcome;
+  if (agent === "cursor") {
+    if (decision) {
+      const message = decision.permissionDecisionReason;
+      return {
+        permission: decision.permissionDecision,
+        user_message: message,
+        agent_message: message
+      };
+    }
+    return context ? { additional_context: context } : null;
+  }
+  const hookEventName = CLAUDE_EVENT[event];
+  if (!hookEventName) return null;
+  if (decision) {
+    const asCodex = agent === "codex" && decision.permissionDecision === "ask" ? {
+      permissionDecision: "deny",
+      permissionDecisionReason: `${decision.permissionDecisionReason} Tell the user what lurq found. Only if they approve, run the install again prefixed with ${ALLOW_ENV}.`
+    } : decision;
+    return { hookSpecificOutput: { hookEventName, ...asCodex } };
+  }
+  return context ? { hookSpecificOutput: { hookEventName, additionalContext: context } } : null;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function runHook(event, agentName = "claude") {
+  try {
+    const agent = HOOK_AGENTS.find((a) => a === agentName);
+    if (!agent) return;
+    const input = normalize(agent, JSON.parse(await readStdin()));
+    const outcome = event === "pre-tool-use" ? await preToolUse(input, agent !== "cursor") : event === "post-tool-use" ? postToolUse(input) : event === "session-start" ? await sessionStart(input, agent) : event === "prompt" ? prompt(input) : null;
+    const output = render(agent, event, outcome);
+    if (output) process.stdout.write(JSON.stringify(output));
+  } catch {
+  }
+}
+export {
+  ALLOW_ENV,
+  HOOK_AGENTS,
+  addedDependencies,
+  applyEdits,
+  decide,
+  installTargets,
+  isJsProject,
+  normalize,
+  patchedPackageJsons,
+  promptTips,
+  render,
+  runHook,
+  runTargets,
+  specName,
+  unseen
+};