lurqrun 0.1.6 → 0.1.7

package/dist/typecheck-X7U5ELMR.js

@@ -0,0 +1,268 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/surface/typecheck.ts
+init_esm_shims();
+import { createRequire } from "module";
+import { dirname, join, relative, resolve } from "path";
+var DEFAULT_BUDGET_MS = 18e4;
+var MESSAGE_CAP = 300;
+var HOP_CAP = 300;
+async function loadCompiler(rootDir) {
+  try {
+    return createRequire(join(resolve(rootDir), "package.json"))("typescript");
+  } catch {
+    try {
+      return (await import("typescript")).default;
+    } catch {
+      return null;
+    }
+  }
+}
+async function createTypeChecker(rootDir, opts = {}) {
+  const ts = await loadCompiler(rootDir);
+  return ts ? typeChecker(ts, rootDir, opts) : void 0;
+}
+function typeChecker(ts, rootDir, opts = {}) {
+  const root = resolve(rootDir);
+  const expiresAt = Date.now() + (opts.budgetMs ?? DEFAULT_BUDGET_MS);
+  const configs = /* @__PURE__ */ new Map();
+  const shareSourceFiles = Number(ts.versionMajorMinor.split(".")[0]) >= 5;
+  const caches = /* @__PURE__ */ new Map();
+  const parse = (configPath) => {
+    if (!configs.has(configPath)) {
+      const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, {
+        ...ts.sys,
+        onUnRecoverableConfigFileDiagnostic: () => {
+        }
+      });
+      configs.set(configPath, parsed ?? null);
+    }
+    return configs.get(configPath);
+  };
+  return (pkg, fromDir, toDir, files) => {
+    if (Date.now() > expiresAt) {
+      return { checked: false, reason: "type check budget used up by earlier packages" };
+    }
+    const groups = groupByProject(ts, root, files, parse);
+    if (groups.size === 0) {
+      return { checked: false, reason: "no tsconfig.json includes the files that import it" };
+    }
+    const installedVersion = manifestVersion(ts, fromDir);
+    const introduced = [];
+    let covered = 0;
+    for (const [configPath, group] of groups) {
+      let cache = caches.get(configPath);
+      if (!cache) caches.set(configPath, cache = /* @__PURE__ */ new Map());
+      const shared = shareSourceFiles ? cache : /* @__PURE__ */ new Map();
+      const before = build(ts, group.parsed, pkg, fromDir, installedVersion, shared, false);
+      if ("reason" in before) return { checked: false, reason: `old version: ${before.reason}` };
+      const files2 = [...group.files, ...importersOf(ts, before.program, group.files)];
+      const beforeDiagnostics = semanticDiagnostics(before.program, files2);
+      if (Date.now() > expiresAt) return { checked: false, reason: "type check ran out of time" };
+      const after = build(ts, group.parsed, pkg, toDir, installedVersion, shared, true);
+      if ("reason" in after) return { checked: false, reason: after.reason };
+      const missingBefore = unresolvedTypeImports(ts, before);
+      const newlyMissing = [...unresolvedTypeImports(ts, after)].filter((s) => !missingBefore.has(s));
+      if (newlyMissing.length) {
+        return {
+          checked: false,
+          reason: `the new version's types import ${newlyMissing.join(", ")}, which is not installed here`
+        };
+      }
+      introduced.push(
+        ...newDiagnostics(ts, root, beforeDiagnostics, semanticDiagnostics(after.program, files2))
+      );
+      covered += files2.length;
+    }
+    return { checked: true, files: covered, introduced };
+  };
+}
+function groupByProject(ts, root, files, parse) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const rel of new Set(files)) {
+    const abs = join(root, rel);
+    const project = projectFor(ts, root, abs, parse);
+    if (!project) continue;
+    const group = groups.get(project.configPath);
+    if (group) group.files.push(abs);
+    else groups.set(project.configPath, { parsed: project.parsed, files: [abs] });
+  }
+  return groups;
+}
+function projectFor(ts, root, abs, parse) {
+  const key = (p) => ts.sys.useCaseSensitiveFileNames ? p : p.toLowerCase();
+  const includes = (parsed) => parsed.fileNames.some((f) => key(resolve(f)) === key(abs));
+  for (let dir = dirname(abs); ; dir = dirname(dir)) {
+    const config = join(dir, "tsconfig.json");
+    if (ts.sys.fileExists(config)) {
+      const parsed = parse(config);
+      if (!parsed) return null;
+      if (includes(parsed)) return { configPath: config, parsed };
+      for (const ref of parsed.projectReferences ?? []) {
+        const refPath = ts.resolveProjectReferencePath(ref);
+        const refParsed = parse(refPath);
+        if (refParsed && includes(refParsed)) return { configPath: refPath, parsed: refParsed };
+      }
+      return null;
+    }
+    if (dir === root || dirname(dir) === dir) return null;
+  }
+}
+function build(ts, parsed, pkg, pkgDir, installedVersion, cache, ownTypes) {
+  const options = { ...parsed.options, noEmit: true, incremental: false };
+  const { host, overlaid } = overlayHost(ts, options, pkg, pkgDir, installedVersion, cache);
+  const program = ts.createProgram({ rootNames: parsed.fileNames, options, host });
+  const declarations = program.getSourceFiles().filter((sf) => sf.isDeclarationFile && overlaid(sf.fileName));
+  if (ownTypes && declarations.length === 0) {
+    return { reason: "the new version ships no type definitions of its own" };
+  }
+  if (declarations.some((sf) => program.getSyntacticDiagnostics(sf).length > 0)) {
+    return { reason: `its type definitions do not parse with TypeScript ${ts.version}` };
+  }
+  return { program, host, overlaid };
+}
+function unresolvedTypeImports(ts, built) {
+  const out = /* @__PURE__ */ new Set();
+  const options = built.program.getCompilerOptions();
+  for (const sf of built.program.getSourceFiles()) {
+    if (!sf.isDeclarationFile || !built.overlaid(sf.fileName)) continue;
+    for (const { fileName: spec } of ts.preProcessFile(sf.text, true, true).importedFiles) {
+      if (!ts.resolveModuleName(spec, sf.fileName, options, built.host).resolvedModule) out.add(spec);
+    }
+  }
+  return out;
+}
+function manifestVersion(ts, dir) {
+  try {
+    const version = JSON.parse(ts.sys.readFile(join(dir, "package.json")) ?? "{}").version;
+    return typeof version === "string" ? version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function semanticDiagnostics(program, files) {
+  return files.flatMap((f) => {
+    const sf = program.getSourceFile(f);
+    return sf ? [...program.getSemanticDiagnostics(sf)] : [];
+  });
+}
+function importersOf(ts, program, targets) {
+  const key = (p) => ts.sys.useCaseSensitiveFileNames ? resolve(p) : resolve(p).toLowerCase();
+  const wanted = new Set(targets.map(key));
+  const options = program.getCompilerOptions();
+  const cache = ts.createModuleResolutionCache(program.getCurrentDirectory(), (f) => key(f), options);
+  const out = [];
+  for (const sf of program.getSourceFiles()) {
+    if (out.length >= HOP_CAP) break;
+    if (sf.isDeclarationFile || sf.fileName.includes("/node_modules/") || wanted.has(key(sf.fileName))) continue;
+    const { importedFiles } = ts.preProcessFile(sf.text, true, true);
+    const imports = importedFiles.some(({ fileName: spec }) => {
+      const hit = ts.resolveModuleName(spec, sf.fileName, options, ts.sys, cache).resolvedModule;
+      return hit !== void 0 && wanted.has(key(hit.resolvedFileName));
+    });
+    if (imports) out.push(sf.fileName);
+  }
+  return out;
+}
+function overlayHost(ts, options, pkg, pkgDir, installedVersion, cache) {
+  const host = ts.createCompilerHost(options, true);
+  const base = {
+    fileExists: host.fileExists.bind(host),
+    readFile: host.readFile.bind(host),
+    directoryExists: host.directoryExists?.bind(host),
+    realpath: host.realpath?.bind(host),
+    getSourceFile: host.getSourceFile.bind(host)
+  };
+  const marker = `/node_modules/${pkg}`;
+  const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pnpmStore = installedVersion ? new RegExp(`^(.*)/node_modules/\\.pnpm/${escape(pkg.replace("/", "+"))}@${escape(installedVersion)}(?:[_(][^/]*)?$`) : null;
+  const ownInstall = (prefix) => {
+    if (!prefix.includes("/node_modules/")) return true;
+    const store = pnpmStore?.exec(prefix);
+    return Boolean(store && !store[1].includes("/node_modules/"));
+  };
+  const direct = (fileName) => {
+    const p = fileName.replace(/\\/g, "/");
+    const i = p.indexOf(marker);
+    if (i < 0 || !ownInstall(p.slice(0, i))) return null;
+    const rest = p.slice(i + marker.length);
+    return rest === "" || rest.startsWith("/") ? pkgDir + rest : null;
+  };
+  const redirect = (fileName) => {
+    const hit = direct(fileName);
+    if (hit !== null || !ts.sys.realpath) return hit;
+    const p = fileName.replace(/\\/g, "/");
+    const i = p.lastIndexOf(marker);
+    const end = i + marker.length;
+    if (i < 0 || p.length > end && p[end] !== "/") return null;
+    const root = ts.sys.realpath(p.slice(0, end)).replace(/\\/g, "/");
+    return root === p.slice(0, end) ? null : direct(root + p.slice(end));
+  };
+  host.fileExists = (p) => {
+    const r = redirect(p);
+    return r === null ? base.fileExists(p) : ts.sys.fileExists(r);
+  };
+  host.readFile = (p) => {
+    const r = redirect(p);
+    return r === null ? base.readFile(p) : ts.sys.readFile(r);
+  };
+  host.directoryExists = (p) => {
+    const r = redirect(p);
+    if (r !== null) return ts.sys.directoryExists(r);
+    const norm = p.replace(/\\/g, "/");
+    if (norm.endsWith("/node_modules") && !norm.slice(0, -"/node_modules".length).includes("/node_modules")) {
+      return true;
+    }
+    return base.directoryExists ? base.directoryExists(p) : ts.sys.directoryExists(p);
+  };
+  host.realpath = (p) => redirect(p) !== null ? p : base.realpath ? base.realpath(p) : p;
+  host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+    const r = redirect(fileName);
+    if (r !== null) {
+      const text = ts.sys.readFile(r);
+      return text === void 0 ? void 0 : ts.createSourceFile(fileName, text, languageVersion);
+    }
+    const hit = cache.get(fileName);
+    if (hit) return hit;
+    const sf = base.getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+    if (sf) cache.set(fileName, sf);
+    return sf;
+  };
+  return { host, overlaid: (fileName) => redirect(fileName) !== null };
+}
+function newDiagnostics(ts, root, before, after) {
+  const where = (d) => d.file && d.start !== void 0 ? { fileName: d.file.fileName, line: d.file.getLineAndCharacterOfPosition(d.start).line + 1 } : null;
+  const remaining = /* @__PURE__ */ new Map();
+  for (const d of before) {
+    const at = where(d);
+    if (!at) continue;
+    const key = `${at.fileName}:${at.line}:${d.code}`;
+    remaining.set(key, (remaining.get(key) ?? 0) + 1);
+  }
+  const out = [];
+  for (const d of after) {
+    const at = where(d);
+    if (!at) continue;
+    const key = `${at.fileName}:${at.line}:${d.code}`;
+    const left = remaining.get(key) ?? 0;
+    if (left > 0) {
+      remaining.set(key, left - 1);
+      continue;
+    }
+    out.push({
+      file: relative(root, at.fileName),
+      line: at.line,
+      code: d.code,
+      message: ts.flattenDiagnosticMessageText(d.messageText, " ").slice(0, MESSAGE_CAP)
+    });
+  }
+  return out;
+}
+export {
+  createTypeChecker,
+  loadCompiler,
+  typeChecker
+};

package/dist/types-M5JP2W3D.js

@@ -0,0 +1,10 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  SEVERITY_RANK,
+  worstSeverity
+} from "./chunk-Q5VPF4WI.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  SEVERITY_RANK,
+  worstSeverity
+};

package/dist/uninstall-P7RGBX6G.js

@@ -0,0 +1,174 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  dim,
+  green,
+  red,
+  yellow
+} from "./chunk-4KCPOMG6.js";
+import {
+  BLOCK_START,
+  agentSpecs,
+  readJsonObject,
+  removeMarkedBlock,
+  resolveAgents,
+  stripTomlBlock,
+  writeFileAtomic,
+  writeJson
+} from "./chunk-UDVNA7EA.js";
+import "./chunk-LUAKDHLZ.js";
+import "./chunk-MYGSLK44.js";
+import {
+  clearUserConfig,
+  lurqHome,
+  userConfigPath
+} from "./chunk-Y5GI7RL3.js";
+import {
+  KEYS_URL,
+  PACKAGE_NAME
+} from "./chunk-GPTKSNR6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/uninstall.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync, rmdirSync, rmSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function removeDirIfEmpty(dir) {
+  if (existsSync(dir) && readdirSync(dir).length === 0) rmdirSync(dir);
+}
+function rewriteOrRemove(path, text) {
+  if (text.trim()) writeFileAtomic(path, text);
+  else rmSync(path, { force: true });
+}
+function mcpEntryRemoval(spec) {
+  if (!existsSync(spec.path)) return null;
+  const label = `${spec.label} MCP entry`;
+  if (spec.format === "toml") {
+    if (!readFileSync(spec.path, "utf8").includes("[mcp_servers.lurq]")) return null;
+    return {
+      label,
+      path: spec.path,
+      apply: () => {
+        const stripped = stripTomlBlock(readFileSync(spec.path, "utf8")).replace(/\s+$/, "");
+        rewriteOrRemove(spec.path, stripped ? `${stripped}
+` : "");
+      }
+    };
+  }
+  const key = spec.format === "servers" ? "servers" : "mcpServers";
+  const servers = readJsonObject(spec.path)[key];
+  if (!servers || typeof servers !== "object" || !Object.hasOwn(servers, "lurq")) return null;
+  return {
+    label,
+    path: spec.path,
+    // Re-read at apply time: the agent may have rewritten its config while the
+    // user was reading the list.
+    apply: () => {
+      const config = readJsonObject(spec.path);
+      delete config[key].lurq;
+      writeJson(spec.path, config);
+    }
+  };
+}
+function instructionsRemoval(spec) {
+  const target = spec.instructions;
+  if (!target || !existsSync(target.path)) return null;
+  if (target.kind === "shared") {
+    if (!readFileSync(target.path, "utf8").includes(BLOCK_START)) return null;
+    return {
+      label: `${spec.label} instructions block`,
+      path: target.path,
+      apply: () => rewriteOrRemove(target.path, removeMarkedBlock(readFileSync(target.path, "utf8")))
+    };
+  }
+  return {
+    label: `${spec.label} ${target.kind === "skill" ? "skill" : "steering file"}`,
+    path: target.path,
+    apply: () => {
+      rmSync(target.path, { force: true });
+      if (target.kind === "skill") removeDirIfEmpty(dirname(target.path));
+    }
+  };
+}
+function planUninstall(specs, opts) {
+  const removals = [];
+  const problems = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (r) => {
+    if (!r || seen.has(r.path)) return;
+    seen.add(r.path);
+    removals.push(r);
+  };
+  for (const spec of specs) {
+    try {
+      add(mcpEntryRemoval(spec));
+    } catch (err) {
+      problems.push(`${spec.label}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    add(instructionsRemoval(spec));
+  }
+  if (opts.global) {
+    const guide = join(lurqHome(), "skill-instructions.md");
+    if (existsSync(guide)) {
+      add({ label: "lurq agent guide", path: guide, apply: () => rmSync(guide, { force: true }) });
+    }
+    if (existsSync(userConfigPath())) {
+      add({
+        label: "stored API key",
+        path: userConfigPath(),
+        apply: () => {
+          clearUserConfig();
+          removeDirIfEmpty(lurqHome());
+        }
+      });
+    }
+  }
+  return { removals, problems };
+}
+async function runUninstall(opts) {
+  const global = !opts.agent || opts.agent === "all";
+  const specs = global ? agentSpecs() : resolveAgents(opts.agent);
+  const { removals, problems } = planUninstall(specs, { global });
+  const short = (p) => p.startsWith(homedir()) ? `~${p.slice(homedir().length)}` : p;
+  for (const p of problems) console.log(`${yellow("!")} ${p}`);
+  if (removals.length === 0) {
+    console.log(`Nothing to remove: lurq is not set up ${global ? "on this machine" : `for ${specs[0].label}`}.`);
+    if (problems.length) process.exitCode = 1;
+    return;
+  }
+  console.log("lurq uninstall removes:");
+  for (const r of removals) console.log(`  \u2022 ${r.label.padEnd(36)} ${short(r.path)}`);
+  console.log(dim("  Everything else in these files stays as it is.\n"));
+  if (!opts.yes) {
+    if (!(process.stdin.isTTY && process.stdout.isTTY)) {
+      throw new Error("Nothing was removed. Re-run with --yes to confirm without a prompt.");
+    }
+    const { confirm } = await import("./dist-4XXIXHHZ.js");
+    if (!await confirm({ message: "Remove these?", default: true })) {
+      console.log("Nothing was removed.");
+      return;
+    }
+  }
+  let failed = problems.length;
+  for (const r of removals) {
+    try {
+      r.apply();
+      console.log(`${green("\u2713")} removed ${r.label}`);
+    } catch (err) {
+      failed++;
+      console.log(`${red("\u2717")} ${r.label}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  console.log("\nRestart your agents so they drop the lurq server.");
+  if (global) {
+    console.log(dim(`The key keeps working until you revoke it: ${KEYS_URL}`));
+    console.log(dim(`To remove the \`lurq\` command as well: npm uninstall -g ${PACKAGE_NAME}`));
+  }
+  if (failed) process.exitCode = 1;
+}
+export {
+  planUninstall,
+  runUninstall
+};