lurqrun 0.1.6 → 0.1.8

package/dist/chunk-DM37MTOO.js

@@ -0,0 +1,636 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  packageRoot
+} from "./chunk-LUAKDHLZ.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import {
+  lurqHome,
+  readUserConfig,
+  resolveApiKey,
+  writeUserConfig
+} from "./chunk-J6XQ7OPZ.js";
+import {
+  DEFAULT_ENDPOINT,
+  PACKAGE_NAME
+} from "./chunk-72Y2FDVS.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/installSkill.ts
+init_esm_shims();
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { copyFileSync } from "fs";
+import { homedir } from "os";
+import { delimiter, dirname, join } from "path";
+var ENV_KEYS = [
+  "DATABASE_URL",
+  "GITHUB_TOKEN",
+  "EMBEDDING_PROVIDER",
+  "EMBEDDING_API_KEY",
+  "EMBEDDING_MODEL",
+  "SUMMARY_PROVIDER",
+  "SUMMARY_API_KEY",
+  "SUMMARY_MODEL"
+];
+function home(...p) {
+  return join(homedir(), ...p);
+}
+function vscodeUserDir() {
+  if (process.platform === "darwin") return home("Library", "Application Support", "Code", "User");
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA ?? home("AppData", "Roaming"), "Code", "User");
+  }
+  return join(process.env.XDG_CONFIG_HOME || home(".config"), "Code", "User");
+}
+function agentSpecs() {
+  return [
+    {
+      id: "claude-code",
+      label: "Claude Code",
+      format: "mcpServers",
+      path: home(".claude.json"),
+      detected: existsSync(home(".claude.json")) || existsSync(home(".claude")),
+      // Personal skills are read from ~/.claude/skills/<name>/SKILL.md and apply
+      // across every project, which is exactly the scope a global install wants.
+      instructions: { kind: "skill", path: home(".claude", "skills", "lurq", "SKILL.md") }
+    },
+    {
+      // No instructions target: Cursor's user-level rules live in its settings
+      // UI, not a file on disk, and its `.cursor/rules/*.mdc` files are
+      // per-project, so there is nothing a machine-wide install can write once.
+      // The MCP tool descriptions carry the guidance here.
+      id: "cursor",
+      label: "Cursor",
+      format: "mcpServers",
+      path: home(".cursor", "mcp.json"),
+      detected: existsSync(home(".cursor"))
+    },
+    {
+      id: "windsurf",
+      label: "Windsurf",
+      format: "mcpServers",
+      path: home(".codeium", "windsurf", "mcp_config.json"),
+      detected: existsSync(home(".codeium")),
+      instructions: {
+        kind: "shared",
+        path: home(".codeium", "windsurf", "memories", "global_rules.md")
+      }
+    },
+    {
+      // No instructions target, for two reasons that compound. A
+      // `.instructions.md` file is only applied automatically when its
+      // frontmatter carries an `applyTo` glob; without one, VS Code requires the
+      // user to attach it to a request by hand. And the user-profile directory
+      // that gets scanned is not a documented default at all: the workspace
+      // default is `.github/instructions`, and profile-level folders come from
+      // the `chat.instructionsFilesLocations` setting. Guessing the path would
+      // write a file nobody reads while reporting success, which is the same
+      // mistake the hardcoded macOS config path made above.
+      id: "copilot",
+      label: "VS Code / GitHub Copilot",
+      format: "servers",
+      path: join(vscodeUserDir(), "mcp.json"),
+      detected: existsSync(vscodeUserDir())
+    },
+    {
+      id: "codex",
+      label: "OpenAI Codex CLI",
+      format: "toml",
+      path: home(".codex", "config.toml"),
+      detected: existsSync(home(".codex")),
+      instructions: { kind: "shared", path: home(".codex", "AGENTS.md") }
+    },
+    {
+      id: "gemini-cli",
+      label: "Gemini CLI",
+      format: "mcpServers",
+      path: home(".gemini", "settings.json"),
+      detected: existsSync(home(".gemini", "settings.json")),
+      // ~/.gemini/GEMINI.md is the global tier of the context hierarchy, loaded
+      // ahead of any workspace file.
+      instructions: { kind: "shared", path: home(".gemini", "GEMINI.md") }
+    },
+    {
+      // Shares the ~/.gemini root with the Gemini CLI but keeps its own file, so
+      // detection has to look at the file rather than at the directory. It reads
+      // the same global GEMINI.md; upserting the block twice is a no-op, so
+      // having both selected is harmless.
+      id: "antigravity",
+      label: "Google Antigravity",
+      format: "mcpServers",
+      path: home(".gemini", "config", "mcp_config.json"),
+      detected: existsSync(home(".gemini", "config")),
+      instructions: { kind: "shared", path: home(".gemini", "GEMINI.md") }
+    },
+    {
+      id: "kiro",
+      label: "Kiro",
+      format: "mcpServers",
+      path: home(".kiro", "settings", "mcp.json"),
+      detected: existsSync(home(".kiro")),
+      // Steering files in ~/.kiro/steering apply to every workspace and are
+      // always included.
+      instructions: { kind: "file", path: home(".kiro", "steering", "lurq.md") }
+    }
+  ];
+}
+var SUPPORTED_AGENTS = [
+  "claude-code",
+  "cursor",
+  "windsurf",
+  "copilot",
+  "codex",
+  "gemini-cli",
+  "antigravity",
+  "kiro"
+];
+function collectEnv() {
+  const env = {};
+  for (const key of ENV_KEYS) {
+    const value = process.env[key];
+    if (value) env[key] = value;
+  }
+  return env;
+}
+function readJsonObject(path) {
+  if (!existsSync(path)) return {};
+  const text = readFileSync(path, "utf8").trim();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    throw new Error(
+      `${path} is not plain JSON (${err instanceof Error ? err.message : String(err)}). If it has comments or trailing commas, lurq will not rewrite it and lose them: remove them and re-run, or edit the "lurq" server entry by hand.`
+    );
+  }
+}
+var KEY_FILE_MODE = 384;
+function writeFileAtomic(path, contents, newFileMode = KEY_FILE_MODE) {
+  let target = path;
+  let mode = newFileMode;
+  try {
+    target = realpathSync(path);
+    mode = statSync(target).mode & 511;
+  } catch {
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  const tmp = `${target}.lurq-${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, contents, { encoding: "utf8", mode });
+    chmodSync(tmp, mode);
+    renameSync(tmp, target);
+  } catch (err) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
+function writeJson(path, obj) {
+  writeFileAtomic(path, JSON.stringify(obj, null, 2) + "\n");
+}
+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 buildRemoteServerEntry(agentId, opts) {
+  const headers = { Authorization: `Bearer ${opts.apiKey}`, "X-Lurq-Client": agentId };
+  switch (agentId) {
+    case "cursor":
+    case "kiro":
+      return { url: opts.url, headers };
+    case "windsurf":
+    case "antigravity":
+      return { serverUrl: opts.url, headers };
+    case "gemini-cli":
+      return { httpUrl: opts.url, headers };
+    case "claude-code":
+    case "copilot":
+    default:
+      return { type: "http", url: opts.url, headers };
+  }
+}
+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 buildRemoteTomlBlock(opts) {
+  return [
+    "[mcp_servers.lurq]",
+    `url = ${JSON.stringify(opts.url)}`,
+    `http_headers = { Authorization = ${JSON.stringify(`Bearer ${opts.apiKey}`)}, X-Lurq-Client = "codex" }`
+  ].join("\n") + "\n";
+}
+function installJsonEntry(spec, entry) {
+  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 = entry;
+  writeJson(spec.path, config);
+  return { agent: spec.id, path: spec.path, status: "installed" };
+}
+function stripTomlBlock(text, header = "[mcp_servers.lurq]") {
+  const lines = text.split("\n");
+  const start = lines.findIndex((l) => l.trim() === header);
+  if (start === -1) return text;
+  let end = start + 1;
+  while (end < lines.length) {
+    const t = lines[end].trim();
+    if (t.startsWith("[") && !t.startsWith(`${header.slice(0, -1)}.`)) break;
+    end++;
+  }
+  return [...lines.slice(0, start), ...lines.slice(end)].join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function installTomlBlock(spec, block) {
+  const current = existsSync(spec.path) ? readFileSync(spec.path, "utf8") : "";
+  const existing = stripTomlBlock(current).replace(/\s+$/, "");
+  const sep = existing ? "\n\n" : "";
+  writeFileAtomic(spec.path, existing + sep + block);
+  return {
+    agent: spec.id,
+    path: spec.path,
+    status: "installed",
+    message: current.includes("[mcp_servers.lurq]") ? "replaced the existing lurq entry" : void 0
+  };
+}
+var BLOCK_START = "<!-- lurq:start -->";
+var BLOCK_END = "<!-- lurq:end -->";
+var SKILL_DESCRIPTION = "Get current, evidence-scored facts about npm packages instead of recalling them. Use before adding, choosing, comparing, or upgrading any JS/TS dependency, before hand-rolling something a package may already do, and before writing code against a package API that may have moved since training. Covers hallucinated and typosquatted package names, advisories, version-exact export surfaces, and stack compatibility.";
+function template(name) {
+  const src = join(packageRoot(), "templates", name);
+  return existsSync(src) ? readFileSync(src, "utf8") : null;
+}
+function upsertMarkedBlock(text, block) {
+  const wrapped = `${BLOCK_START}
+${block.trim()}
+${BLOCK_END}`;
+  const start = text.indexOf(BLOCK_START);
+  if (start === -1) {
+    const existing = text.replace(/\s+$/, "");
+    return existing ? `${existing}
+
+${wrapped}
+` : `${wrapped}
+`;
+  }
+  const endAt = text.indexOf(BLOCK_END, start);
+  const after = endAt === -1 ? "" : text.slice(endAt + BLOCK_END.length);
+  return `${text.slice(0, start)}${wrapped}${after.replace(/^\n*/, "\n")}`;
+}
+function removeMarkedBlock(text) {
+  const start = text.indexOf(BLOCK_START);
+  if (start === -1) return text;
+  const endAt = text.indexOf(BLOCK_END, start);
+  const before = text.slice(0, start).replace(/\s+$/, "");
+  const after = endAt === -1 ? "" : text.slice(endAt + BLOCK_END.length).replace(/^\s+/, "");
+  const joined = [before, after].filter(Boolean).join("\n\n");
+  return joined ? joined.replace(/\s*$/, "\n") : "";
+}
+function buildSkillFile(guide) {
+  return [
+    "---",
+    "name: lurq",
+    `description: ${SKILL_DESCRIPTION}`,
+    "---",
+    "",
+    guide.trim(),
+    ""
+  ].join("\n");
+}
+function installInstructions(spec) {
+  const target = spec.instructions;
+  if (!target) return null;
+  if (target.kind === "shared") {
+    const brief = template("agent-rules.md");
+    if (!brief) return null;
+    const current = existsSync(target.path) ? readFileSync(target.path, "utf8") : "";
+    writeFileAtomic(target.path, upsertMarkedBlock(current, brief), 420);
+    return target.path;
+  }
+  const guide = template("skill-instructions.md");
+  if (!guide) return null;
+  writeFileAtomic(target.path, target.kind === "skill" ? buildSkillFile(guide) : guide, 420);
+  return target.path;
+}
+var HOOK_TARGETS = {
+  claude: {
+    label: "Claude Code hooks",
+    // Hooks live in settings.json; Claude Code's MCP servers are in ~/.claude.json.
+    path: () => home(".claude", "settings.json"),
+    flat: false,
+    hooks: [
+      {
+        event: "SessionStart",
+        matcher: "startup|clear|compact",
+        arg: "session-start",
+        timeout: 10
+      },
+      { event: "UserPromptSubmit", arg: "prompt", timeout: 5 },
+      {
+        event: "PreToolUse",
+        matcher: "Bash|Edit|Write|MultiEdit",
+        arg: "pre-tool-use",
+        timeout: 30
+      }
+    ]
+  },
+  codex: {
+    label: "Codex hooks",
+    path: () => home(".codex", "hooks.json"),
+    flat: false,
+    hooks: [
+      {
+        event: "SessionStart",
+        matcher: "startup|clear|compact",
+        arg: "session-start",
+        timeout: 10
+      },
+      { event: "UserPromptSubmit", arg: "prompt", timeout: 5 },
+      { event: "PreToolUse", matcher: "Bash|apply_patch", arg: "pre-tool-use", timeout: 30 }
+    ]
+  },
+  cursor: {
+    label: "Cursor hooks",
+    path: () => home(".cursor", "hooks.json"),
+    flat: true,
+    hooks: [
+      { event: "sessionStart", arg: "session-start", timeout: 10 },
+      { event: "beforeShellExecution", arg: "pre-tool-use", timeout: 30 },
+      { event: "postToolUse", matcher: "Shell", arg: "post-tool-use", timeout: 5 }
+    ]
+  }
+};
+var AGENT_HOOKS = {
+  "claude-code": "claude",
+  codex: "codex",
+  cursor: "cursor"
+};
+var hookAgentFor = (specId) => AGENT_HOOKS[specId] ?? null;
+var hooksPath = (agent) => HOOK_TARGETS[agent].path();
+var hooksLabel = (agent) => HOOK_TARGETS[agent].label;
+var isLurqCommand = (h) => typeof h?.command === "string" && / hook (--agent [a-z]+ )?(session-start|prompt|pre-tool-use|post-tool-use)$/.test(h.command);
+var holdsLurq = (g) => isLurqCommand(g) || Array.isArray(g?.hooks) && g.hooks.some(isLurqCommand);
+var hasLurqHooks = (config) => Object.values(config.hooks ?? {}).some(
+  (groups) => Array.isArray(groups) && groups.some(holdsLurq)
+);
+function withoutLurqHooks(config) {
+  if (!hasLurqHooks(config)) return config;
+  const hooks = {};
+  for (const [event, groups] of Object.entries(config.hooks)) {
+    if (!Array.isArray(groups)) {
+      hooks[event] = groups;
+      continue;
+    }
+    const kept = groups.flatMap((g) => {
+      if (isLurqCommand(g)) return [];
+      if (!holdsLurq(g)) return [g];
+      const rest = g.hooks.filter((h) => !isLurqCommand(h));
+      return rest.length ? [{ ...g, hooks: rest }] : [];
+    });
+    if (kept.length || groups.length === 0) hooks[event] = kept;
+  }
+  const next = { ...config, hooks };
+  if (Object.keys(hooks).length === 0) delete next.hooks;
+  return next;
+}
+function withLurqHooks(config, agent, lurq) {
+  const target = HOOK_TARGETS[agent];
+  const base = withoutLurqHooks(config);
+  const hooks = { ...base.hooks };
+  const flag = agent === "claude" ? "" : ` --agent ${agent}`;
+  for (const h of target.hooks) {
+    const command = `${lurq} hook${flag} ${h.arg}`;
+    const matcher = h.matcher ? { matcher: h.matcher } : {};
+    const entry = target.flat ? { command, ...matcher, timeout: h.timeout } : { ...matcher, hooks: [{ type: "command", command, timeout: h.timeout }] };
+    hooks[h.event] = [...Array.isArray(hooks[h.event]) ? hooks[h.event] : [], entry];
+  }
+  return target.flat ? { version: 1, ...base, hooks } : { ...base, hooks };
+}
+function lurqCommandFor(agent, invocation) {
+  if (agent !== "cursor" || !invocation.path) return invocation.command;
+  return /\s/.test(invocation.path) ? JSON.stringify(invocation.path) : invocation.path;
+}
+function hasLurqEntry(spec) {
+  try {
+    if (!existsSync(spec.path)) return false;
+    if (spec.format === "toml")
+      return readFileSync(spec.path, "utf8").includes("[mcp_servers.lurq]");
+    const servers = readJsonObject(spec.path)[spec.format === "servers" ? "servers" : "mcpServers"];
+    return !!servers && typeof servers === "object" && Object.hasOwn(servers, "lurq");
+  } catch {
+    return false;
+  }
+}
+function installHooks(agent, path = hooksPath(agent), invocation = lurqInvocation()) {
+  if (!invocation.onPath) return null;
+  const codexToml = home(".codex", "config.toml");
+  if (agent === "codex" && existsSync(codexToml) && /^\s*\[\[?hooks[.\]]/m.test(readFileSync(codexToml, "utf8")))
+    return null;
+  const lurq = lurqCommandFor(agent, invocation);
+  writeJson(path, withLurqHooks(readJsonObject(path), agent, lurq));
+  writeUserConfig({ hooks: { ...readUserConfig().hooks, [agent]: { command: lurq } } });
+  return path;
+}
+function installAgent(spec, mode) {
+  try {
+    const result = spec.format === "toml" ? installTomlBlock(
+      spec,
+      mode.kind === "remote" ? buildRemoteTomlBlock(mode) : buildTomlBlock(mode.env)
+    ) : installJsonEntry(
+      spec,
+      mode.kind === "remote" ? buildRemoteServerEntry(spec.id, mode) : buildServerEntry(mode.env, spec.format === "servers")
+    );
+    try {
+      result.instructionsPath = installInstructions(spec) ?? void 0;
+    } catch (err) {
+      result.message = `MCP entry written; instructions file failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    const hookAgent = hookAgentFor(spec.id);
+    if (hookAgent) {
+      try {
+        result.hookPath = installHooks(hookAgent) ?? void 0;
+      } catch (err) {
+        result.message = `MCP entry written; hooks failed: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+    return result;
+  } catch (err) {
+    return {
+      agent: spec.id,
+      path: spec.path,
+      status: "error",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function installInstructionsFile() {
+  const src = join(packageRoot(), "templates", "skill-instructions.md");
+  if (!existsSync(src)) return null;
+  const destDir = lurqHome();
+  const dest = join(destDir, "skill-instructions.md");
+  mkdirSync(destDir, { recursive: true });
+  copyFileSync(src, dest);
+  return dest;
+}
+function resolveAgents(target) {
+  const specs = agentSpecs();
+  if (target === "all") return specs.filter((s) => s.detected);
+  const spec = specs.find((s) => s.id === target);
+  if (!spec) {
+    throw new Error(`Unknown agent "${target}". Supported: ${SUPPORTED_AGENTS.join(", ")}, all.`);
+  }
+  return [spec];
+}
+function lurqInvocation() {
+  const candidates = process.platform === "win32" ? [".cmd", ".exe", ""] : [""];
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of candidates) {
+      try {
+        const path = join(dir, `lurq${ext}`);
+        accessSync(path, constants.X_OK);
+        return { command: "lurq", onPath: true, path };
+      } catch {
+      }
+    }
+  }
+  return { command: `npx ${PACKAGE_NAME}`, onPath: false };
+}
+function printInstallReport(results, instructionsPath, mode) {
+  const specs = agentSpecs();
+  const short = (p) => p.startsWith(homedir()) ? `~${p.slice(homedir().length)}` : p;
+  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)} ${short(r.path)}${r.message ? `  (${r.message})` : ""}`
+    );
+  }
+  const withSkills = results.filter((r) => r.instructionsPath);
+  if (withSkills.length) {
+    console.log("\nAgent instructions (so it reaches for lurq on its own):");
+    for (const r of withSkills) {
+      const spec = specs.find((s) => s.id === r.agent);
+      console.log(`  \u2713 ${spec.label.padEnd(26)} ${short(r.instructionsPath)}`);
+    }
+  }
+  const hooked = results.filter((r) => r.hookPath);
+  if (hooked.length) {
+    console.log("\nHooks (installs verified first, lurq suggested where it helps):");
+    for (const r of hooked)
+      console.log(
+        `  \u2713 ${specs.find((s) => s.id === r.agent).label.padEnd(26)} ${short(r.hookPath)}`
+      );
+    if (hooked.some((r) => r.agent === "codex"))
+      console.log("  \u2022 Codex skips new hooks until you trust them: run /hooks in Codex once.");
+  }
+  if (instructionsPath) console.log(`
+Full guide: ${short(instructionsPath)}`);
+  console.log("\nNext steps:");
+  if (mode.kind === "local") {
+    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.");
+  } else {
+    console.log("  1. Restart the agent so it picks up the new MCP server.");
+  }
+  console.log("  \u2022 Ask it to add a package. It should check the package with lurq first.");
+  const { command, onPath } = lurqInvocation();
+  console.log(`  \u2022 Or use the terminal directly: \`${command} verify zod\`.`);
+  if (!onPath) {
+    console.log(`
+  There is no \`lurq\` command on this machine yet. Everything above`);
+    console.log("  worked and your agents are wired up; only the terminal shortcut is");
+    console.log(`  missing, so use \`npx ${PACKAGE_NAME} <command>\`. To get \`lurq\` itself:`);
+    console.log(`      npm install -g ${PACKAGE_NAME}`);
+  }
+}
+async function runInstallSkill(opts) {
+  const selected = resolveAgents(opts.agent ?? "claude-code");
+  if (selected.length === 0) {
+    console.log("No supported agents detected on this machine.");
+    return;
+  }
+  const remote = !opts.local;
+  let mode;
+  if (remote) {
+    const apiKey = resolveApiKey(opts.apiKey);
+    if (!apiKey) {
+      throw new Error(
+        "An API key is required for a hosted install. Pass --api-key <key> (or set LURQ_API_KEY), or run `lurq setup` for the guided setup, or --local to self-host."
+      );
+    }
+    const url = opts.url ?? process.env.LURQ_ENDPOINT ?? DEFAULT_ENDPOINT;
+    mode = { kind: "remote", url, apiKey };
+  } else {
+    const env = collectEnv();
+    if (!env.DATABASE_URL) {
+      logger.warn(
+        "DATABASE_URL is not set, the local server entry will have no DATABASE_URL. Set it (in .env) and re-run, or edit the config."
+      );
+    }
+    mode = { kind: "local", env };
+  }
+  const results = selected.map((spec) => installAgent(spec, mode));
+  const instructionsPath = installInstructionsFile();
+  printInstallReport(results, instructionsPath, mode);
+}
+
+export {
+  agentSpecs,
+  SUPPORTED_AGENTS,
+  readJsonObject,
+  writeFileAtomic,
+  writeJson,
+  buildServerEntry,
+  buildRemoteServerEntry,
+  buildTomlBlock,
+  buildRemoteTomlBlock,
+  stripTomlBlock,
+  BLOCK_START,
+  upsertMarkedBlock,
+  removeMarkedBlock,
+  buildSkillFile,
+  installInstructions,
+  hookAgentFor,
+  hooksPath,
+  hooksLabel,
+  hasLurqHooks,
+  withoutLurqHooks,
+  withLurqHooks,
+  lurqCommandFor,
+  hasLurqEntry,
+  installHooks,
+  installAgent,
+  installInstructionsFile,
+  resolveAgents,
+  lurqInvocation,
+  printInstallReport,
+  runInstallSkill
+};