@llmnesia/mcp 0.1.0 → 0.1.2

package/dist/cli.js

@@ -1,2812 +1,58 @@
 #!/usr/bin/env node
+import { createRequire as __llmnesiaCreateRequire } from "node:module";
+const require = __llmnesiaCreateRequire(import.meta.url);
 import {
-  Corpus,
-  SearchIndex,
-  VERSION,
-  deleteIndexDb,
-  drainInbox,
-  ingestFile,
-  openSearchIndex,
-  resolveCorpusDir
-} from "./chunk-OBJD6H4A.js";
-
-// src/cli.ts
-import { createInterface } from "readline/promises";
-
-// ../packages/native-host/install.mjs
-import { execFile } from "child_process";
-import { chmod, mkdir, readFile, rm, stat, writeFile } from "fs/promises";
-import { homedir, platform } from "os";
-import { dirname, join, resolve } from "path";
-import { fileURLToPath } from "url";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var HOST_NAME = "com.llmnesia.claude_code";
-var STORE_EXTENSION_ID = "leekfgbdojiaabifbjbbgiiclannjdkf";
-var here = dirname(fileURLToPath(import.meta.url));
-var home = homedir();
-var osPlatform = process.env.LLMNESIA_FAKE_PLATFORM || platform();
-function expandHome(p) {
-  if (p === "~") {
-    return home;
-  }
-  if (p.startsWith("~/") || p.startsWith("~\\")) {
-    return resolve(home, p.slice(2));
-  }
-  return resolve(p);
-}
-function resolveCorpusDir2(explicit) {
-  const raw = explicit ?? process.env.LLMNESIA_CORPUS_DIR ?? "~/.llmnesia/corpus";
-  return expandHome(raw);
-}
-async function exists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function posixBrowsers(homeDir = home, forPlatform = osPlatform) {
-  if (forPlatform === "darwin") {
-    const base2 = join(homeDir, "Library", "Application Support");
-    return [
-      ["Brave", join(base2, "BraveSoftware", "Brave-Browser")],
-      ["Chrome", join(base2, "Google", "Chrome")],
-      ["Edge", join(base2, "Microsoft Edge")],
-      ["Chromium", join(base2, "Chromium")]
-    ];
-  }
-  const base = join(homeDir, ".config");
-  return [
-    ["Brave", join(base, "BraveSoftware", "Brave-Browser")],
-    ["Chrome", join(base, "google-chrome")],
-    ["Edge", join(base, "microsoft-edge")],
-    ["Chromium", join(base, "chromium")]
-  ];
-}
-async function installPosix(manifestBase, hostPath) {
-  const manifest = { ...manifestBase, path: hostPath };
-  let installed = 0;
-  for (const [label, browserDir] of posixBrowsers()) {
-    if (!await exists(browserDir)) {
-      continue;
-    }
-    const dir = join(browserDir, "NativeMessagingHosts");
-    await mkdir(dir, { recursive: true });
-    await writeFile(join(dir, `${HOST_NAME}.json`), `${JSON.stringify(manifest, null, 2)}
-`, "utf8");
-    console.log(`Manifest \u2192 ${label}: ${join(dir, `${HOST_NAME}.json`)}`);
-    installed += 1;
-  }
-  return installed;
-}
-function windowsBrowsers() {
-  const localAppData = process.env.LOCALAPPDATA || join(home, "AppData", "Local");
-  return [
-    ["Brave", join(localAppData, "BraveSoftware", "Brave-Browser", "User Data"), "Software\\BraveSoftware\\Brave-Browser"],
-    ["Chrome", join(localAppData, "Google", "Chrome", "User Data"), "Software\\Google\\Chrome"],
-    ["Edge", join(localAppData, "Microsoft", "Edge", "User Data"), "Software\\Microsoft\\Edge"],
-    ["Chromium", join(localAppData, "Chromium", "User Data"), "Software\\Chromium"]
-  ];
-}
-async function installWindows(manifestBase, hostPath, installDir) {
-  const batPath = join(installDir, "llmnesia-claude-host.bat");
-  await writeFile(batPath, `@echo off\r
-"${process.execPath}" "${hostPath}" %*\r
-`, "utf8");
-  console.log(`Launcher \u2192 ${batPath}`);
-  const manifest = { ...manifestBase, path: batPath };
-  const manifestPath = join(installDir, `${HOST_NAME}.json`);
-  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`, "utf8");
-  console.log(`Manifest \u2192 ${manifestPath}`);
-  let installed = 0;
-  for (const [label, userDataDir, vendorKey] of windowsBrowsers()) {
-    if (!await exists(userDataDir)) {
-      continue;
-    }
-    const key = `HKCU\\${vendorKey}\\NativeMessagingHosts\\${HOST_NAME}`;
-    const regExe = join(process.env.SystemRoot || "C:\\Windows", "System32", "reg.exe");
-    await execFileAsync(regExe, ["add", key, "/ve", "/t", "REG_SZ", "/d", manifestPath, "/f"]);
-    console.log(`Registry \u2192 ${label}: ${key}`);
-    installed += 1;
-  }
-  return installed;
-}
-async function installNativeHost({ ids = [], corpus, force = false } = {}) {
-  const isWindows2 = osPlatform === "win32";
-  const allIds = [.../* @__PURE__ */ new Set([STORE_EXTENSION_ID, ...ids])];
-  const allowedOrigins = allIds.map((id) => `chrome-extension://${id}/`);
-  const installDir = join(home, ".llmnesia");
-  await mkdir(installDir, { recursive: true });
-  const hostSource = await readFile(join(here, "llmnesia-claude-host.mjs"), "utf8");
-  const hosted = isWindows2 ? hostSource : hostSource.replace(/^#![^\n]*\n/, `#!${process.execPath}
-`);
-  const hostPath = join(installDir, "llmnesia-claude-host.mjs");
-  await writeFile(hostPath, hosted, "utf8");
-  if (!isWindows2) {
-    await chmod(hostPath, 493);
-  }
-  console.log(`Host script \u2192 ${hostPath}`);
-  const manifestBase = {
-    name: HOST_NAME,
-    description: "LLMnesia \u2014 reads local Claude Code sessions",
-    type: "stdio",
-    allowed_origins: allowedOrigins
-  };
-  const installedCount = isWindows2 ? await installWindows(manifestBase, hostPath, installDir) : await installPosix(manifestBase, hostPath);
-  if (installedCount === 0) {
-    throw new Error("No Chromium-based browsers found \u2014 nothing to install.");
-  }
-  const configPath = join(installDir, "config.json");
-  const corpusRoot = resolveCorpusDir2(corpus);
-  let existing = null;
-  try {
-    existing = JSON.parse(await readFile(configPath, "utf8"));
-  } catch {
-  }
-  const existingRoot = existing && typeof existing.corpusRoot === "string" ? existing.corpusRoot : null;
-  let corpusRootChanged = true;
-  if (existingRoot && existingRoot !== corpusRoot && !force) {
-    corpusRootChanged = false;
-    console.log(`Corpus config kept \u2192 ${configPath}`);
-    console.log(`  already points at: ${existingRoot}`);
-    console.log(`  to change it: re-run with --corpus <dir> --force`);
-  } else {
-    await writeFile(configPath, `${JSON.stringify({ corpusRoot }, null, 2)}
-`, { encoding: "utf8", mode: 384 });
-    await chmod(configPath, 384);
-    console.log(`Corpus config \u2192 ${configPath}`);
-    console.log(`  corpus root: ${corpusRoot}`);
-  }
-  console.log(`
-Done. Allowed extension id(s): ${allIds.join(", ")}`);
-  console.log("Fully quit and reopen the browser, then open LLMnesia Settings.");
-  return {
-    installedCount,
-    allowedIds: allIds,
-    configPath,
-    corpusRoot: existingRoot && !corpusRootChanged ? existingRoot : corpusRoot,
-    corpusRootChanged
-  };
-}
-async function uninstallNativeHost() {
-  const isWindows2 = osPlatform === "win32";
-  const removed = [];
-  const installDir = join(home, ".llmnesia");
-  if (isWindows2) {
-    const manifestPath = join(installDir, `${HOST_NAME}.json`);
-    const batPath = join(installDir, "llmnesia-claude-host.bat");
-    for (const [label, userDataDir, vendorKey] of windowsBrowsers()) {
-      if (!await exists(userDataDir)) {
-        continue;
-      }
-      const key = `HKCU\\${vendorKey}\\NativeMessagingHosts\\${HOST_NAME}`;
-      const regExe = join(process.env.SystemRoot || "C:\\Windows", "System32", "reg.exe");
-      try {
-        await execFileAsync(regExe, ["delete", key, "/f"]);
-        removed.push(`registry:${label}`);
-      } catch {
-      }
-    }
-    await rm(manifestPath, { force: true });
-    await rm(batPath, { force: true });
-    removed.push("manifest", "launcher");
-  } else {
-    for (const [label, browserDir] of posixBrowsers()) {
-      if (!await exists(browserDir)) {
-        continue;
-      }
-      const manifestPath = join(browserDir, "NativeMessagingHosts", `${HOST_NAME}.json`);
-      if (await exists(manifestPath)) {
-        await rm(manifestPath, { force: true });
-        removed.push(`manifest:${label}`);
-      }
-    }
-  }
-  const hostScriptPath = join(installDir, "llmnesia-claude-host.mjs");
-  if (await exists(hostScriptPath)) {
-    await rm(hostScriptPath, { force: true });
-    removed.push("host-script");
-  }
-  const corpusRoot = resolveCorpusDir2();
-  return { removed, corpusRoot };
-}
-
-// src/args.ts
-var OPTION_ALIASES = {
-  c: "corpus",
-  n: "limit",
-  v: "version",
-  h: "help",
-  y: "yes"
-};
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["force", "yes", "version", "help"]);
-function parseArgs(argv) {
-  const positionals = [];
-  const options = {};
-  const flags = /* @__PURE__ */ new Set();
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg.startsWith("--") && arg.includes("=")) {
-      const eq = arg.indexOf("=");
-      options[arg.slice(2, eq)] = arg.slice(eq + 1);
-    } else if (arg.startsWith("--")) {
-      const key = arg.slice(2);
-      if (BOOLEAN_FLAGS.has(key)) {
-        flags.add(key);
-      } else {
-        options[key] = argv[++i] ?? "";
-      }
-    } else if (arg.startsWith("-") && arg.length === 2) {
-      const key = OPTION_ALIASES[arg.slice(1)] ?? arg.slice(1);
-      if (BOOLEAN_FLAGS.has(key)) {
-        flags.add(key);
-      } else {
-        options[key] = argv[++i] ?? "";
-      }
-    } else {
-      positionals.push(arg);
-    }
-  }
-  return { command: positionals[0], positionals: positionals.slice(1), options, flags };
-}
-
-// ../node_modules/chokidar/esm/index.js
-import { stat as statcb } from "fs";
-import { stat as stat4, readdir as readdir2 } from "fs/promises";
-import { EventEmitter } from "events";
-import * as sysPath2 from "path";
-
-// ../node_modules/readdirp/esm/index.js
-import { stat as stat2, lstat, readdir, realpath } from "fs/promises";
-import { Readable } from "stream";
-import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "path";
-var EntryTypes = {
-  FILE_TYPE: "files",
-  DIR_TYPE: "directories",
-  FILE_DIR_TYPE: "files_directories",
-  EVERYTHING_TYPE: "all"
-};
-var defaultOptions = {
-  root: ".",
-  fileFilter: (_entryInfo) => true,
-  directoryFilter: (_entryInfo) => true,
-  type: EntryTypes.FILE_TYPE,
-  lstat: false,
-  depth: 2147483648,
-  alwaysStat: false,
-  highWaterMark: 4096
-};
-Object.freeze(defaultOptions);
-var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
-var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
-var ALL_TYPES = [
-  EntryTypes.DIR_TYPE,
-  EntryTypes.EVERYTHING_TYPE,
-  EntryTypes.FILE_DIR_TYPE,
-  EntryTypes.FILE_TYPE
-];
-var DIR_TYPES = /* @__PURE__ */ new Set([
-  EntryTypes.DIR_TYPE,
-  EntryTypes.EVERYTHING_TYPE,
-  EntryTypes.FILE_DIR_TYPE
-]);
-var FILE_TYPES = /* @__PURE__ */ new Set([
-  EntryTypes.EVERYTHING_TYPE,
-  EntryTypes.FILE_DIR_TYPE,
-  EntryTypes.FILE_TYPE
-]);
-var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
-var wantBigintFsStats = process.platform === "win32";
-var emptyFn = (_entryInfo) => true;
-var normalizeFilter = (filter) => {
-  if (filter === void 0)
-    return emptyFn;
-  if (typeof filter === "function")
-    return filter;
-  if (typeof filter === "string") {
-    const fl = filter.trim();
-    return (entry) => entry.basename === fl;
-  }
-  if (Array.isArray(filter)) {
-    const trItems = filter.map((item) => item.trim());
-    return (entry) => trItems.some((f) => entry.basename === f);
-  }
-  return emptyFn;
-};
-var ReaddirpStream = class extends Readable {
-  constructor(options = {}) {
-    super({
-      objectMode: true,
-      autoDestroy: true,
-      highWaterMark: options.highWaterMark
-    });
-    const opts = { ...defaultOptions, ...options };
-    const { root, type } = opts;
-    this._fileFilter = normalizeFilter(opts.fileFilter);
-    this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat : stat2;
-    if (wantBigintFsStats) {
-      this._stat = (path) => statMethod(path, { bigint: true });
-    } else {
-      this._stat = statMethod;
-    }
-    this._maxDepth = opts.depth ?? defaultOptions.depth;
-    this._wantsDir = type ? DIR_TYPES.has(type) : false;
-    this._wantsFile = type ? FILE_TYPES.has(type) : false;
-    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-    this._root = presolve(root);
-    this._isDirent = !opts.alwaysStat;
-    this._statsProp = this._isDirent ? "dirent" : "stats";
-    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
-    this.parents = [this._exploreDir(root, 1)];
-    this.reading = false;
-    this.parent = void 0;
-  }
-  async _read(batch) {
-    if (this.reading)
-      return;
-    this.reading = true;
-    try {
-      while (!this.destroyed && batch > 0) {
-        const par = this.parent;
-        const fil = par && par.files;
-        if (fil && fil.length > 0) {
-          const { path, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
-          const awaited = await Promise.all(slice);
-          for (const entry of awaited) {
-            if (!entry)
-              continue;
-            if (this.destroyed)
-              return;
-            const entryType = await this._getEntryType(entry);
-            if (entryType === "directory" && this._directoryFilter(entry)) {
-              if (depth <= this._maxDepth) {
-                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
-              }
-              if (this._wantsDir) {
-                this.push(entry);
-                batch--;
-              }
-            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
-              if (this._wantsFile) {
-                this.push(entry);
-                batch--;
-              }
-            }
-          }
-        } else {
-          const parent = this.parents.pop();
-          if (!parent) {
-            this.push(null);
-            break;
-          }
-          this.parent = await parent;
-          if (this.destroyed)
-            return;
-        }
-      }
-    } catch (error) {
-      this.destroy(error);
-    } finally {
-      this.reading = false;
-    }
-  }
-  async _exploreDir(path, depth) {
-    let files;
-    try {
-      files = await readdir(path, this._rdOptions);
-    } catch (error) {
-      this._onError(error);
-    }
-    return { files, depth, path };
-  }
-  async _formatEntry(dirent, path) {
-    let entry;
-    const basename3 = this._isDirent ? dirent.name : dirent;
-    try {
-      const fullPath = presolve(pjoin(path, basename3));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
-      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
-    } catch (err) {
-      this._onError(err);
-      return;
-    }
-    return entry;
-  }
-  _onError(err) {
-    if (isNormalFlowError(err) && !this.destroyed) {
-      this.emit("warn", err);
-    } else {
-      this.destroy(err);
-    }
-  }
-  async _getEntryType(entry) {
-    if (!entry && this._statsProp in entry) {
-      return "";
-    }
-    const stats = entry[this._statsProp];
-    if (stats.isFile())
-      return "file";
-    if (stats.isDirectory())
-      return "directory";
-    if (stats && stats.isSymbolicLink()) {
-      const full = entry.fullPath;
-      try {
-        const entryRealPath = await realpath(full);
-        const entryRealPathStats = await lstat(entryRealPath);
-        if (entryRealPathStats.isFile()) {
-          return "file";
-        }
-        if (entryRealPathStats.isDirectory()) {
-          const len = entryRealPath.length;
-          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
-            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
-            recursiveError.code = RECURSIVE_ERROR_CODE;
-            return this._onError(recursiveError);
-          }
-          return "directory";
-        }
-      } catch (error) {
-        this._onError(error);
-        return "";
-      }
-    }
-  }
-  _includeAsFile(entry) {
-    const stats = entry && entry[this._statsProp];
-    return stats && this._wantsEverything && !stats.isDirectory();
-  }
-};
-function readdirp(root, options = {}) {
-  let type = options.entryType || options.type;
-  if (type === "both")
-    type = EntryTypes.FILE_DIR_TYPE;
-  if (type)
-    options.type = type;
-  if (!root) {
-    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
-  } else if (typeof root !== "string") {
-    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
-  } else if (type && !ALL_TYPES.includes(type)) {
-    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
-  }
-  options.root = root;
-  return new ReaddirpStream(options);
-}
-
-// ../node_modules/chokidar/esm/handler.js
-import { watchFile, unwatchFile, watch as fs_watch } from "fs";
-import { open, stat as stat3, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
-import * as sysPath from "path";
-import { type as osType } from "os";
-var STR_DATA = "data";
-var STR_END = "end";
-var STR_CLOSE = "close";
-var EMPTY_FN = () => {
-};
-var pl = process.platform;
-var isWindows = pl === "win32";
-var isMacos = pl === "darwin";
-var isLinux = pl === "linux";
-var isFreeBSD = pl === "freebsd";
-var isIBMi = osType() === "OS400";
-var EVENTS = {
-  ALL: "all",
-  READY: "ready",
-  ADD: "add",
-  CHANGE: "change",
-  ADD_DIR: "addDir",
-  UNLINK: "unlink",
-  UNLINK_DIR: "unlinkDir",
-  RAW: "raw",
-  ERROR: "error"
-};
-var EV = EVENTS;
-var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat2, stat: stat3 };
-var KEY_LISTENERS = "listeners";
-var KEY_ERR = "errHandlers";
-var KEY_RAW = "rawEmitters";
-var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
-var binaryExtensions = /* @__PURE__ */ new Set([
-  "3dm",
-  "3ds",
-  "3g2",
-  "3gp",
-  "7z",
-  "a",
-  "aac",
-  "adp",
-  "afdesign",
-  "afphoto",
-  "afpub",
-  "ai",
-  "aif",
-  "aiff",
-  "alz",
-  "ape",
-  "apk",
-  "appimage",
-  "ar",
-  "arj",
-  "asf",
-  "au",
-  "avi",
-  "bak",
-  "baml",
-  "bh",
-  "bin",
-  "bk",
-  "bmp",
-  "btif",
-  "bz2",
-  "bzip2",
-  "cab",
-  "caf",
-  "cgm",
-  "class",
-  "cmx",
-  "cpio",
-  "cr2",
-  "cur",
-  "dat",
-  "dcm",
-  "deb",
-  "dex",
-  "djvu",
-  "dll",
-  "dmg",
-  "dng",
-  "doc",
-  "docm",
-  "docx",
-  "dot",
-  "dotm",
-  "dra",
-  "DS_Store",
-  "dsk",
-  "dts",
-  "dtshd",
-  "dvb",
-  "dwg",
-  "dxf",
-  "ecelp4800",
-  "ecelp7470",
-  "ecelp9600",
-  "egg",
-  "eol",
-  "eot",
-  "epub",
-  "exe",
-  "f4v",
-  "fbs",
-  "fh",
-  "fla",
-  "flac",
-  "flatpak",
-  "fli",
-  "flv",
-  "fpx",
-  "fst",
-  "fvt",
-  "g3",
-  "gh",
-  "gif",
-  "graffle",
-  "gz",
-  "gzip",
-  "h261",
-  "h263",
-  "h264",
-  "icns",
-  "ico",
-  "ief",
-  "img",
-  "ipa",
-  "iso",
-  "jar",
-  "jpeg",
-  "jpg",
-  "jpgv",
-  "jpm",
-  "jxr",
-  "key",
-  "ktx",
-  "lha",
-  "lib",
-  "lvp",
-  "lz",
-  "lzh",
-  "lzma",
-  "lzo",
-  "m3u",
-  "m4a",
-  "m4v",
-  "mar",
-  "mdi",
-  "mht",
-  "mid",
-  "midi",
-  "mj2",
-  "mka",
-  "mkv",
-  "mmr",
-  "mng",
-  "mobi",
-  "mov",
-  "movie",
-  "mp3",
-  "mp4",
-  "mp4a",
-  "mpeg",
-  "mpg",
-  "mpga",
-  "mxu",
-  "nef",
-  "npx",
-  "numbers",
-  "nupkg",
-  "o",
-  "odp",
-  "ods",
-  "odt",
-  "oga",
-  "ogg",
-  "ogv",
-  "otf",
-  "ott",
-  "pages",
-  "pbm",
-  "pcx",
-  "pdb",
-  "pdf",
-  "pea",
-  "pgm",
-  "pic",
-  "png",
-  "pnm",
-  "pot",
-  "potm",
-  "potx",
-  "ppa",
-  "ppam",
-  "ppm",
-  "pps",
-  "ppsm",
-  "ppsx",
-  "ppt",
-  "pptm",
-  "pptx",
-  "psd",
-  "pya",
-  "pyc",
-  "pyo",
-  "pyv",
-  "qt",
-  "rar",
-  "ras",
-  "raw",
-  "resources",
-  "rgb",
-  "rip",
-  "rlc",
-  "rmf",
-  "rmvb",
-  "rpm",
-  "rtf",
-  "rz",
-  "s3m",
-  "s7z",
-  "scpt",
-  "sgi",
-  "shar",
-  "snap",
-  "sil",
-  "sketch",
-  "slk",
-  "smv",
-  "snk",
-  "so",
-  "stl",
-  "suo",
-  "sub",
-  "swf",
-  "tar",
-  "tbz",
-  "tbz2",
-  "tga",
-  "tgz",
-  "thmx",
-  "tif",
-  "tiff",
-  "tlz",
-  "ttc",
-  "ttf",
-  "txz",
-  "udf",
-  "uvh",
-  "uvi",
-  "uvm",
-  "uvp",
-  "uvs",
-  "uvu",
-  "viv",
-  "vob",
-  "war",
-  "wav",
-  "wax",
-  "wbmp",
-  "wdp",
-  "weba",
-  "webm",
-  "webp",
-  "whl",
-  "wim",
-  "wm",
-  "wma",
-  "wmv",
-  "wmx",
-  "woff",
-  "woff2",
-  "wrm",
-  "wvx",
-  "xbm",
-  "xif",
-  "xla",
-  "xlam",
-  "xls",
-  "xlsb",
-  "xlsm",
-  "xlsx",
-  "xlt",
-  "xltm",
-  "xltx",
-  "xm",
-  "xmind",
-  "xpi",
-  "xpm",
-  "xwd",
-  "xz",
-  "z",
-  "zip",
-  "zipx"
-]);
-var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
-var foreach = (val, fn) => {
-  if (val instanceof Set) {
-    val.forEach(fn);
-  } else {
-    fn(val);
-  }
-};
-var addAndConvert = (main2, prop, item) => {
-  let container = main2[prop];
-  if (!(container instanceof Set)) {
-    main2[prop] = container = /* @__PURE__ */ new Set([container]);
-  }
-  container.add(item);
-};
-var clearItem = (cont) => (key) => {
-  const set = cont[key];
-  if (set instanceof Set) {
-    set.clear();
-  } else {
-    delete cont[key];
-  }
-};
-var delFromSet = (main2, prop, item) => {
-  const container = main2[prop];
-  if (container instanceof Set) {
-    container.delete(item);
-  } else if (container === item) {
-    delete main2[prop];
-  }
-};
-var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
-var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
-  const handleEvent = (rawEvent, evPath) => {
-    listener(path);
-    emitRaw(rawEvent, evPath, { watchedPath: path });
-    if (evPath && path !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
-    }
-  };
-  try {
-    return fs_watch(path, {
-      persistent: options.persistent
-    }, handleEvent);
-  } catch (error) {
-    errHandler(error);
-    return void 0;
-  }
-}
-var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
-  const cont = FsWatchInstances.get(fullPath);
-  if (!cont)
-    return;
-  foreach(cont[listenerType], (listener) => {
-    listener(val1, val2, val3);
-  });
-};
-var setFsWatchListener = (path, fullPath, options, handlers) => {
-  const { listener, errHandler, rawEmitter } = handlers;
-  let cont = FsWatchInstances.get(fullPath);
-  let watcher;
-  if (!options.persistent) {
-    watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
-    if (!watcher)
-      return;
-    return watcher.close.bind(watcher);
-  }
-  if (cont) {
-    addAndConvert(cont, KEY_LISTENERS, listener);
-    addAndConvert(cont, KEY_ERR, errHandler);
-    addAndConvert(cont, KEY_RAW, rawEmitter);
-  } else {
-    watcher = createFsWatchInstance(
-      path,
-      options,
-      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
-      errHandler,
-      // no need to use broadcast here
-      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
-    );
-    if (!watcher)
-      return;
-    watcher.on(EV.ERROR, async (error) => {
-      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
-      if (cont)
-        cont.watcherUnusable = true;
-      if (isWindows && error.code === "EPERM") {
-        try {
-          const fd = await open(path, "r");
-          await fd.close();
-          broadcastErr(error);
-        } catch (err) {
-        }
-      } else {
-        broadcastErr(error);
-      }
-    });
-    cont = {
-      listeners: listener,
-      errHandlers: errHandler,
-      rawEmitters: rawEmitter,
-      watcher
-    };
-    FsWatchInstances.set(fullPath, cont);
-  }
-  return () => {
-    delFromSet(cont, KEY_LISTENERS, listener);
-    delFromSet(cont, KEY_ERR, errHandler);
-    delFromSet(cont, KEY_RAW, rawEmitter);
-    if (isEmptySet(cont.listeners)) {
-      cont.watcher.close();
-      FsWatchInstances.delete(fullPath);
-      HANDLER_KEYS.forEach(clearItem(cont));
-      cont.watcher = void 0;
-      Object.freeze(cont);
-    }
-  };
-};
-var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path, fullPath, options, handlers) => {
-  const { listener, rawEmitter } = handlers;
-  let cont = FsWatchFileInstances.get(fullPath);
-  const copts = cont && cont.options;
-  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-    unwatchFile(fullPath);
-    cont = void 0;
-  }
-  if (cont) {
-    addAndConvert(cont, KEY_LISTENERS, listener);
-    addAndConvert(cont, KEY_RAW, rawEmitter);
-  } else {
-    cont = {
-      listeners: listener,
-      rawEmitters: rawEmitter,
-      options,
-      watcher: watchFile(fullPath, options, (curr, prev) => {
-        foreach(cont.rawEmitters, (rawEmitter2) => {
-          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
-        });
-        const currmtime = curr.mtimeMs;
-        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path, curr));
-        }
-      })
-    };
-    FsWatchFileInstances.set(fullPath, cont);
-  }
-  return () => {
-    delFromSet(cont, KEY_LISTENERS, listener);
-    delFromSet(cont, KEY_RAW, rawEmitter);
-    if (isEmptySet(cont.listeners)) {
-      FsWatchFileInstances.delete(fullPath);
-      unwatchFile(fullPath);
-      cont.options = cont.watcher = void 0;
-      Object.freeze(cont);
-    }
-  };
-};
-var NodeFsHandler = class {
-  constructor(fsW) {
-    this.fsw = fsW;
-    this._boundHandleError = (error) => fsW._handleError(error);
-  }
-  /**
-   * Watch file for changes with fs_watchFile or fs_watch.
-   * @param path to file or dir
-   * @param listener on fs change
-   * @returns closer for the watcher instance
-   */
-  _watchWithNodeFs(path, listener) {
-    const opts = this.fsw.options;
-    const directory = sysPath.dirname(path);
-    const basename3 = sysPath.basename(path);
-    const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename3);
-    const absolutePath = sysPath.resolve(path);
-    const options = {
-      persistent: opts.persistent
-    };
-    if (!listener)
-      listener = EMPTY_FN;
-    let closer;
-    if (opts.usePolling) {
-      const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path, absolutePath, options, {
-        listener,
-        rawEmitter: this.fsw._emitRaw
-      });
-    } else {
-      closer = setFsWatchListener(path, absolutePath, options, {
-        listener,
-        errHandler: this._boundHandleError,
-        rawEmitter: this.fsw._emitRaw
-      });
-    }
-    return closer;
-  }
-  /**
-   * Watch a file and emit add event if warranted.
-   * @returns closer for the watcher instance
-   */
-  _handleFile(file, stats, initialAdd) {
-    if (this.fsw.closed) {
-      return;
-    }
-    const dirname7 = sysPath.dirname(file);
-    const basename3 = sysPath.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname7);
-    let prevStats = stats;
-    if (parent.has(basename3))
-      return;
-    const listener = async (path, newStats) => {
-      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
-        return;
-      if (!newStats || newStats.mtimeMs === 0) {
-        try {
-          const newStats2 = await stat3(file);
-          if (this.fsw.closed)
-            return;
-          const at = newStats2.atimeMs;
-          const mt = newStats2.mtimeMs;
-          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-            this.fsw._emit(EV.CHANGE, file, newStats2);
-          }
-          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path);
-            prevStats = newStats2;
-            const closer2 = this._watchWithNodeFs(file, listener);
-            if (closer2)
-              this.fsw._addPathCloser(path, closer2);
-          } else {
-            prevStats = newStats2;
-          }
-        } catch (error) {
-          this.fsw._remove(dirname7, basename3);
-        }
-      } else if (parent.has(basename3)) {
-        const at = newStats.atimeMs;
-        const mt = newStats.mtimeMs;
-        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-          this.fsw._emit(EV.CHANGE, file, newStats);
-        }
-        prevStats = newStats;
-      }
-    };
-    const closer = this._watchWithNodeFs(file, listener);
-    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
-      if (!this.fsw._throttle(EV.ADD, file, 0))
-        return;
-      this.fsw._emit(EV.ADD, file, stats);
-    }
-    return closer;
-  }
-  /**
-   * Handle symlinks encountered while reading a dir.
-   * @param entry returned by readdirp
-   * @param directory path of dir being read
-   * @param path of this item
-   * @param item basename of this item
-   * @returns true if no more processing is needed for this entry.
-   */
-  async _handleSymlink(entry, directory, path, item) {
-    if (this.fsw.closed) {
-      return;
-    }
-    const full = entry.fullPath;
-    const dir = this.fsw._getWatchedDir(directory);
-    if (!this.fsw.options.followSymlinks) {
-      this.fsw._incrReadyCount();
-      let linkPath;
-      try {
-        linkPath = await fsrealpath(path);
-      } catch (e) {
-        this.fsw._emitReady();
-        return true;
-      }
-      if (this.fsw.closed)
-        return;
-      if (dir.has(item)) {
-        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
-          this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path, entry.stats);
-        }
-      } else {
-        dir.add(item);
-        this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path, entry.stats);
-      }
-      this.fsw._emitReady();
-      return true;
-    }
-    if (this.fsw._symlinkPaths.has(full)) {
-      return true;
-    }
-    this.fsw._symlinkPaths.set(full, true);
-  }
-  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-    directory = sysPath.join(directory, "");
-    throttler = this.fsw._throttle("readdir", directory, 1e3);
-    if (!throttler)
-      return;
-    const previous = this.fsw._getWatchedDir(wh.path);
-    const current = /* @__PURE__ */ new Set();
-    let stream = this.fsw._readdirp(directory, {
-      fileFilter: (entry) => wh.filterPath(entry),
-      directoryFilter: (entry) => wh.filterDir(entry)
-    });
-    if (!stream)
-      return;
-    stream.on(STR_DATA, async (entry) => {
-      if (this.fsw.closed) {
-        stream = void 0;
-        return;
-      }
-      const item = entry.path;
-      let path = sysPath.join(directory, item);
-      current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
-        return;
-      }
-      if (this.fsw.closed) {
-        stream = void 0;
-        return;
-      }
-      if (item === target || !target && !previous.has(item)) {
-        this.fsw._incrReadyCount();
-        path = sysPath.join(dir, sysPath.relative(dir, path));
-        this._addToNodeFs(path, initialAdd, wh, depth + 1);
-      }
-    }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve4, reject) => {
-      if (!stream)
-        return reject();
-      stream.once(STR_END, () => {
-        if (this.fsw.closed) {
-          stream = void 0;
-          return;
-        }
-        const wasThrottled = throttler ? throttler.clear() : false;
-        resolve4(void 0);
-        previous.getChildren().filter((item) => {
-          return item !== directory && !current.has(item);
-        }).forEach((item) => {
-          this.fsw._remove(directory, item);
-        });
-        stream = void 0;
-        if (wasThrottled)
-          this._handleRead(directory, false, wh, target, dir, depth, throttler);
-      });
-    });
-  }
-  /**
-   * Read directory to add / remove files from `@watched` list and re-read it on change.
-   * @param dir fs path
-   * @param stats
-   * @param initialAdd
-   * @param depth relative to user-supplied path
-   * @param target child path targeted for watch
-   * @param wh Common watch helpers for this path
-   * @param realpath
-   * @returns closer for the watcher instance.
-   */
-  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
-    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-    const tracked = parentDir.has(sysPath.basename(dir));
-    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
-      this.fsw._emit(EV.ADD_DIR, dir, stats);
-    }
-    parentDir.add(sysPath.basename(dir));
-    this.fsw._getWatchedDir(dir);
-    let throttler;
-    let closer;
-    const oDepth = this.fsw.options.depth;
-    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
-      if (!target) {
-        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
-        if (this.fsw.closed)
-          return;
-      }
-      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
-        if (stats2 && stats2.mtimeMs === 0)
-          return;
-        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
-      });
-    }
-    return closer;
-  }
-  /**
-   * Handle added file, directory, or glob pattern.
-   * Delegates call to _handleFile / _handleDir after checks.
-   * @param path to file or ir
-   * @param initialAdd was the file added at watch instantiation?
-   * @param priorWh depth relative to user-supplied path
-   * @param depth Child path actually targeted for watch
-   * @param target Child path actually targeted for watch
-   */
-  async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
-    const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path) || this.fsw.closed) {
-      ready();
-      return false;
-    }
-    const wh = this.fsw._getWatchHelpers(path);
-    if (priorWh) {
-      wh.filterPath = (entry) => priorWh.filterPath(entry);
-      wh.filterDir = (entry) => priorWh.filterDir(entry);
-    }
-    try {
-      const stats = await statMethods[wh.statMethod](wh.watchPath);
-      if (this.fsw.closed)
-        return;
-      if (this.fsw._isIgnored(wh.watchPath, stats)) {
-        ready();
-        return false;
-      }
-      const follow = this.fsw.options.followSymlinks;
-      let closer;
-      if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path);
-        const targetPath = follow ? await fsrealpath(path) : path;
-        if (this.fsw.closed)
-          return;
-        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
-        if (this.fsw.closed)
-          return;
-        if (absPath !== targetPath && targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(absPath, targetPath);
-        }
-      } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path) : path;
-        if (this.fsw.closed)
-          return;
-        const parent = sysPath.dirname(wh.watchPath);
-        this.fsw._getWatchedDir(parent).add(wh.watchPath);
-        this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
-        if (this.fsw.closed)
-          return;
-        if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
-        }
-      } else {
-        closer = this._handleFile(wh.watchPath, stats, initialAdd);
-      }
-      ready();
-      if (closer)
-        this.fsw._addPathCloser(path, closer);
-      return false;
-    } catch (error) {
-      if (this.fsw._handleError(error)) {
-        ready();
-        return path;
-      }
-    }
-  }
-};
-
-// ../node_modules/chokidar/esm/index.js
-var SLASH = "/";
-var SLASH_SLASH = "//";
-var ONE_DOT = ".";
-var TWO_DOTS = "..";
-var STRING_TYPE = "string";
-var BACK_SLASH_RE = /\\/g;
-var DOUBLE_SLASH_RE = /\/\//;
-var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
-var REPLACER_RE = /^\.[/\\]/;
-function arrify(item) {
-  return Array.isArray(item) ? item : [item];
-}
-var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
-function createPattern(matcher) {
-  if (typeof matcher === "function")
-    return matcher;
-  if (typeof matcher === "string")
-    return (string) => matcher === string;
-  if (matcher instanceof RegExp)
-    return (string) => matcher.test(string);
-  if (typeof matcher === "object" && matcher !== null) {
-    return (string) => {
-      if (matcher.path === string)
-        return true;
-      if (matcher.recursive) {
-        const relative3 = sysPath2.relative(matcher.path, string);
-        if (!relative3) {
-          return false;
-        }
-        return !relative3.startsWith("..") && !sysPath2.isAbsolute(relative3);
-      }
-      return false;
-    };
-  }
-  return () => false;
-}
-function normalizePath(path) {
-  if (typeof path !== "string")
-    throw new Error("string expected");
-  path = sysPath2.normalize(path);
-  path = path.replace(/\\/g, "/");
-  let prepend = false;
-  if (path.startsWith("//"))
-    prepend = true;
-  const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path.match(DOUBLE_SLASH_RE2))
-    path = path.replace(DOUBLE_SLASH_RE2, "/");
-  if (prepend)
-    path = "/" + path;
-  return path;
-}
-function matchPatterns(patterns, testString, stats) {
-  const path = normalizePath(testString);
-  for (let index = 0; index < patterns.length; index++) {
-    const pattern = patterns[index];
-    if (pattern(path, stats)) {
-      return true;
-    }
-  }
-  return false;
-}
-function anymatch(matchers, testString) {
-  if (matchers == null) {
-    throw new TypeError("anymatch: specify first argument");
-  }
-  const matchersArray = arrify(matchers);
-  const patterns = matchersArray.map((matcher) => createPattern(matcher));
-  if (testString == null) {
-    return (testString2, stats) => {
-      return matchPatterns(patterns, testString2, stats);
-    };
-  }
-  return matchPatterns(patterns, testString);
-}
-var unifyPaths = (paths_) => {
-  const paths2 = arrify(paths_).flat();
-  if (!paths2.every((p) => typeof p === STRING_TYPE)) {
-    throw new TypeError(`Non-string provided as watch path: ${paths2}`);
-  }
-  return paths2.map(normalizePathToUnix);
-};
-var toUnix = (string) => {
-  let str = string.replace(BACK_SLASH_RE, SLASH);
-  let prepend = false;
-  if (str.startsWith(SLASH_SLASH)) {
-    prepend = true;
-  }
-  while (str.match(DOUBLE_SLASH_RE)) {
-    str = str.replace(DOUBLE_SLASH_RE, SLASH);
-  }
-  if (prepend) {
-    str = SLASH + str;
-  }
-  return str;
-};
-var normalizePathToUnix = (path) => toUnix(sysPath2.normalize(toUnix(path)));
-var normalizeIgnored = (cwd = "") => (path) => {
-  if (typeof path === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path) ? path : sysPath2.join(cwd, path));
-  } else {
-    return path;
-  }
-};
-var getAbsolutePath = (path, cwd) => {
-  if (sysPath2.isAbsolute(path)) {
-    return path;
-  }
-  return sysPath2.join(cwd, path);
-};
-var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
-var DirEntry = class {
-  constructor(dir, removeWatcher) {
-    this.path = dir;
-    this._removeWatcher = removeWatcher;
-    this.items = /* @__PURE__ */ new Set();
-  }
-  add(item) {
-    const { items } = this;
-    if (!items)
-      return;
-    if (item !== ONE_DOT && item !== TWO_DOTS)
-      items.add(item);
-  }
-  async remove(item) {
-    const { items } = this;
-    if (!items)
-      return;
-    items.delete(item);
-    if (items.size > 0)
-      return;
-    const dir = this.path;
-    try {
-      await readdir2(dir);
-    } catch (err) {
-      if (this._removeWatcher) {
-        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
-      }
-    }
-  }
-  has(item) {
-    const { items } = this;
-    if (!items)
-      return;
-    return items.has(item);
-  }
-  getChildren() {
-    const { items } = this;
-    if (!items)
-      return [];
-    return [...items.values()];
-  }
-  dispose() {
-    this.items.clear();
-    this.path = "";
-    this._removeWatcher = EMPTY_FN;
-    this.items = EMPTY_SET;
-    Object.freeze(this);
-  }
-};
-var STAT_METHOD_F = "stat";
-var STAT_METHOD_L = "lstat";
-var WatchHelper = class {
-  constructor(path, follow, fsw) {
-    this.fsw = fsw;
-    const watchPath = path;
-    this.path = path = path.replace(REPLACER_RE, "");
-    this.watchPath = watchPath;
-    this.fullWatchPath = sysPath2.resolve(watchPath);
-    this.dirParts = [];
-    this.dirParts.forEach((parts) => {
-      if (parts.length > 1)
-        parts.pop();
-    });
-    this.followSymlinks = follow;
-    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
-  }
-  entryPath(entry) {
-    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
-  }
-  filterPath(entry) {
-    const { stats } = entry;
-    if (stats && stats.isSymbolicLink())
-      return this.filterDir(entry);
-    const resolvedPath = this.entryPath(entry);
-    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
-  }
-  filterDir(entry) {
-    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
-  }
-};
-var FSWatcher = class extends EventEmitter {
-  // Not indenting methods for history sake; for now.
-  constructor(_opts = {}) {
-    super();
-    this.closed = false;
-    this._closers = /* @__PURE__ */ new Map();
-    this._ignoredPaths = /* @__PURE__ */ new Set();
-    this._throttled = /* @__PURE__ */ new Map();
-    this._streams = /* @__PURE__ */ new Set();
-    this._symlinkPaths = /* @__PURE__ */ new Map();
-    this._watched = /* @__PURE__ */ new Map();
-    this._pendingWrites = /* @__PURE__ */ new Map();
-    this._pendingUnlinks = /* @__PURE__ */ new Map();
-    this._readyCount = 0;
-    this._readyEmitted = false;
-    const awf = _opts.awaitWriteFinish;
-    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
-    const opts = {
-      // Defaults
-      persistent: true,
-      ignoreInitial: false,
-      ignorePermissionErrors: false,
-      interval: 100,
-      binaryInterval: 300,
-      followSymlinks: true,
-      usePolling: false,
-      // useAsync: false,
-      atomic: true,
-      // NOTE: overwritten later (depends on usePolling)
-      ..._opts,
-      // Change format
-      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
-      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
-    };
-    if (isIBMi)
-      opts.usePolling = true;
-    if (opts.atomic === void 0)
-      opts.atomic = !opts.usePolling;
-    const envPoll = process.env.CHOKIDAR_USEPOLLING;
-    if (envPoll !== void 0) {
-      const envLower = envPoll.toLowerCase();
-      if (envLower === "false" || envLower === "0")
-        opts.usePolling = false;
-      else if (envLower === "true" || envLower === "1")
-        opts.usePolling = true;
-      else
-        opts.usePolling = !!envLower;
-    }
-    const envInterval = process.env.CHOKIDAR_INTERVAL;
-    if (envInterval)
-      opts.interval = Number.parseInt(envInterval, 10);
-    let readyCalls = 0;
-    this._emitReady = () => {
-      readyCalls++;
-      if (readyCalls >= this._readyCount) {
-        this._emitReady = EMPTY_FN;
-        this._readyEmitted = true;
-        process.nextTick(() => this.emit(EVENTS.READY));
-      }
-    };
-    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
-    this._boundRemove = this._remove.bind(this);
-    this.options = opts;
-    this._nodeFsHandler = new NodeFsHandler(this);
-    Object.freeze(opts);
-  }
-  _addIgnoredPath(matcher) {
-    if (isMatcherObject(matcher)) {
-      for (const ignored of this._ignoredPaths) {
-        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
-          return;
-        }
-      }
-    }
-    this._ignoredPaths.add(matcher);
-  }
-  _removeIgnoredPath(matcher) {
-    this._ignoredPaths.delete(matcher);
-    if (typeof matcher === "string") {
-      for (const ignored of this._ignoredPaths) {
-        if (isMatcherObject(ignored) && ignored.path === matcher) {
-          this._ignoredPaths.delete(ignored);
-        }
-      }
-    }
-  }
-  // Public methods
-  /**
-   * Adds paths to be watched on an existing FSWatcher instance.
-   * @param paths_ file or file list. Other arguments are unused
-   */
-  add(paths_, _origAdd, _internal) {
-    const { cwd } = this.options;
-    this.closed = false;
-    this._closePromise = void 0;
-    let paths2 = unifyPaths(paths_);
-    if (cwd) {
-      paths2 = paths2.map((path) => {
-        const absPath = getAbsolutePath(path, cwd);
-        return absPath;
-      });
-    }
-    paths2.forEach((path) => {
-      this._removeIgnoredPath(path);
-    });
-    this._userIgnored = void 0;
-    if (!this._readyCount)
-      this._readyCount = 0;
-    this._readyCount += paths2.length;
-    Promise.all(paths2.map(async (path) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
-      if (res)
-        this._emitReady();
-      return res;
-    })).then((results) => {
-      if (this.closed)
-        return;
-      results.forEach((item) => {
-        if (item)
-          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
-      });
-    });
-    return this;
-  }
-  /**
-   * Close watchers or start ignoring events from specified paths.
-   */
-  unwatch(paths_) {
-    if (this.closed)
-      return this;
-    const paths2 = unifyPaths(paths_);
-    const { cwd } = this.options;
-    paths2.forEach((path) => {
-      if (!sysPath2.isAbsolute(path) && !this._closers.has(path)) {
-        if (cwd)
-          path = sysPath2.join(cwd, path);
-        path = sysPath2.resolve(path);
-      }
-      this._closePath(path);
-      this._addIgnoredPath(path);
-      if (this._watched.has(path)) {
-        this._addIgnoredPath({
-          path,
-          recursive: true
-        });
-      }
-      this._userIgnored = void 0;
-    });
-    return this;
-  }
-  /**
-   * Close watchers and remove all listeners from watched paths.
-   */
-  close() {
-    if (this._closePromise) {
-      return this._closePromise;
-    }
-    this.closed = true;
-    this.removeAllListeners();
-    const closers = [];
-    this._closers.forEach((closerList) => closerList.forEach((closer) => {
-      const promise = closer();
-      if (promise instanceof Promise)
-        closers.push(promise);
-    }));
-    this._streams.forEach((stream) => stream.destroy());
-    this._userIgnored = void 0;
-    this._readyCount = 0;
-    this._readyEmitted = false;
-    this._watched.forEach((dirent) => dirent.dispose());
-    this._closers.clear();
-    this._watched.clear();
-    this._streams.clear();
-    this._symlinkPaths.clear();
-    this._throttled.clear();
-    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
-    return this._closePromise;
-  }
-  /**
-   * Expose list of watched paths
-   * @returns for chaining
-   */
-  getWatched() {
-    const watchList = {};
-    this._watched.forEach((entry, dir) => {
-      const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
-      const index = key || ONE_DOT;
-      watchList[index] = entry.getChildren().sort();
-    });
-    return watchList;
-  }
-  emitWithAll(event, args) {
-    this.emit(event, ...args);
-    if (event !== EVENTS.ERROR)
-      this.emit(EVENTS.ALL, event, ...args);
-  }
-  // Common helpers
-  // --------------
-  /**
-   * Normalize and emit events.
-   * Calling _emit DOES NOT MEAN emit() would be called!
-   * @param event Type of event
-   * @param path File or directory path
-   * @param stats arguments to be passed with event
-   * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
-   */
-  async _emit(event, path, stats) {
-    if (this.closed)
-      return;
-    const opts = this.options;
-    if (isWindows)
-      path = sysPath2.normalize(path);
-    if (opts.cwd)
-      path = sysPath2.relative(opts.cwd, path);
-    const args = [path];
-    if (stats != null)
-      args.push(stats);
-    const awf = opts.awaitWriteFinish;
-    let pw;
-    if (awf && (pw = this._pendingWrites.get(path))) {
-      pw.lastChange = /* @__PURE__ */ new Date();
-      return this;
-    }
-    if (opts.atomic) {
-      if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path, [event, ...args]);
-        setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path2) => {
-            this.emit(...entry);
-            this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path2);
-          });
-        }, typeof opts.atomic === "number" ? opts.atomic : 100);
-        return this;
-      }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
-        event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path);
-      }
-    }
-    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
-      const awfEmit = (err, stats2) => {
-        if (err) {
-          event = EVENTS.ERROR;
-          args[0] = err;
-          this.emitWithAll(event, args);
-        } else if (stats2) {
-          if (args.length > 1) {
-            args[1] = stats2;
-          } else {
-            args.push(stats2);
-          }
-          this.emitWithAll(event, args);
-        }
-      };
-      this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
-      return this;
-    }
-    if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path, 50);
-      if (isThrottled)
-        return this;
-    }
-    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path) : path;
-      let stats2;
-      try {
-        stats2 = await stat4(fullPath);
-      } catch (err) {
-      }
-      if (!stats2 || this.closed)
-        return;
-      args.push(stats2);
-    }
-    this.emitWithAll(event, args);
-    return this;
-  }
-  /**
-   * Common handler for errors
-   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
-   */
-  _handleError(error) {
-    const code = error && error.code;
-    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
-      this.emit(EVENTS.ERROR, error);
-    }
-    return error || this.closed;
-  }
-  /**
-   * Helper utility for throttling
-   * @param actionType type being throttled
-   * @param path being acted upon
-   * @param timeout duration of time to suppress duplicate actions
-   * @returns tracking object or false if action should be suppressed
-   */
-  _throttle(actionType, path, timeout) {
-    if (!this._throttled.has(actionType)) {
-      this._throttled.set(actionType, /* @__PURE__ */ new Map());
-    }
-    const action = this._throttled.get(actionType);
-    if (!action)
-      throw new Error("invalid throttle");
-    const actionPath = action.get(path);
-    if (actionPath) {
-      actionPath.count++;
-      return false;
-    }
-    let timeoutObject;
-    const clear = () => {
-      const item = action.get(path);
-      const count = item ? item.count : 0;
-      action.delete(path);
-      clearTimeout(timeoutObject);
-      if (item)
-        clearTimeout(item.timeoutObject);
-      return count;
-    };
-    timeoutObject = setTimeout(clear, timeout);
-    const thr = { timeoutObject, clear, count: 0 };
-    action.set(path, thr);
-    return thr;
-  }
-  _incrReadyCount() {
-    return this._readyCount++;
-  }
-  /**
-   * Awaits write operation to finish.
-   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
-   * @param path being acted upon
-   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
-   * @param event
-   * @param awfEmit Callback to be called when ready for event to be emitted.
-   */
-  _awaitWriteFinish(path, threshold, event, awfEmit) {
-    const awf = this.options.awaitWriteFinish;
-    if (typeof awf !== "object")
-      return;
-    const pollInterval = awf.pollInterval;
-    let timeoutHandler;
-    let fullPath = path;
-    if (this.options.cwd && !sysPath2.isAbsolute(path)) {
-      fullPath = sysPath2.join(this.options.cwd, path);
-    }
-    const now = /* @__PURE__ */ new Date();
-    const writes = this._pendingWrites;
-    function awaitWriteFinishFn(prevStat) {
-      statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path)) {
-          if (err && err.code !== "ENOENT")
-            awfEmit(err);
-          return;
-        }
-        const now2 = Number(/* @__PURE__ */ new Date());
-        if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path).lastChange = now2;
-        }
-        const pw = writes.get(path);
-        const df = now2 - pw.lastChange;
-        if (df >= threshold) {
-          writes.delete(path);
-          awfEmit(void 0, curStat);
-        } else {
-          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
-        }
-      });
-    }
-    if (!writes.has(path)) {
-      writes.set(path, {
-        lastChange: now,
-        cancelWait: () => {
-          writes.delete(path);
-          clearTimeout(timeoutHandler);
-          return event;
-        }
-      });
-      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
-    }
-  }
-  /**
-   * Determines whether user has asked to ignore this path.
-   */
-  _isIgnored(path, stats) {
-    if (this.options.atomic && DOT_RE.test(path))
-      return true;
-    if (!this._userIgnored) {
-      const { cwd } = this.options;
-      const ign = this.options.ignored;
-      const ignored = (ign || []).map(normalizeIgnored(cwd));
-      const ignoredPaths = [...this._ignoredPaths];
-      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
-      this._userIgnored = anymatch(list, void 0);
-    }
-    return this._userIgnored(path, stats);
-  }
-  _isntIgnored(path, stat6) {
-    return !this._isIgnored(path, stat6);
-  }
-  /**
-   * Provides a set of common helpers and properties relating to symlink handling.
-   * @param path file or directory pattern being watched
-   */
-  _getWatchHelpers(path) {
-    return new WatchHelper(path, this.options.followSymlinks, this);
-  }
-  // Directory helpers
-  // -----------------
-  /**
-   * Provides directory tracking objects
-   * @param directory path of the directory
-   */
-  _getWatchedDir(directory) {
-    const dir = sysPath2.resolve(directory);
-    if (!this._watched.has(dir))
-      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
-    return this._watched.get(dir);
-  }
-  // File helpers
-  // ------------
-  /**
-   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
-   */
-  _hasReadPermissions(stats) {
-    if (this.options.ignorePermissionErrors)
-      return true;
-    return Boolean(Number(stats.mode) & 256);
-  }
-  /**
-   * Handles emitting unlink events for
-   * files and directories, and via recursion, for
-   * files and directories within directories that are unlinked
-   * @param directory within which the following item is located
-   * @param item      base path of item/directory
-   */
-  _remove(directory, item, isDirectory) {
-    const path = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path, 100))
-      return;
-    if (!isDirectory && this._watched.size === 1) {
-      this.add(directory, item, true);
-    }
-    const wp = this._getWatchedDir(path);
-    const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
-    const parent = this._getWatchedDir(directory);
-    const wasTracked = parent.has(item);
-    parent.remove(item);
-    if (this._symlinkPaths.has(fullPath)) {
-      this._symlinkPaths.delete(fullPath);
-    }
-    let relPath = path;
-    if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path);
-    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
-      const event = this._pendingWrites.get(relPath).cancelWait();
-      if (event === EVENTS.ADD)
-        return;
-    }
-    this._watched.delete(path);
-    this._watched.delete(fullPath);
-    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path))
-      this._emit(eventName, path);
-    this._closePath(path);
-  }
-  /**
-   * Closes all watchers for a path
-   */
-  _closePath(path) {
-    this._closeFile(path);
-    const dir = sysPath2.dirname(path);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path));
-  }
-  /**
-   * Closes only file-specific watchers
-   */
-  _closeFile(path) {
-    const closers = this._closers.get(path);
-    if (!closers)
-      return;
-    closers.forEach((closer) => closer());
-    this._closers.delete(path);
-  }
-  _addPathCloser(path, closer) {
-    if (!closer)
-      return;
-    let list = this._closers.get(path);
-    if (!list) {
-      list = [];
-      this._closers.set(path, list);
-    }
-    list.push(closer);
-  }
-  _readdirp(root, opts) {
-    if (this.closed)
-      return;
-    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
-    let stream = readdirp(root, options);
-    this._streams.add(stream);
-    stream.once(STR_CLOSE, () => {
-      stream = void 0;
-    });
-    stream.once(STR_END, () => {
-      if (stream) {
-        this._streams.delete(stream);
-        stream = void 0;
-      }
-    });
-    return stream;
-  }
-};
-function watch(paths2, options = {}) {
-  const watcher = new FSWatcher(options);
-  watcher.add(paths2);
-  return watcher;
-}
-var esm_default = { watch, FSWatcher };
-
-// src/watch.ts
-async function watchInbox(corpus, onDrain) {
-  await corpus.init();
-  const index = await openSearchIndex(corpus);
-  let draining = false;
-  let pending = false;
-  const runDrain = async () => {
-    if (draining) {
-      pending = true;
-      return;
-    }
-    draining = true;
-    try {
-      do {
-        pending = false;
-        const report = await drainInbox(corpus, index);
-        if (report.files > 0) {
-          onDrain?.(report);
-        }
-      } while (pending);
-    } finally {
-      draining = false;
-    }
-  };
-  const watcher = esm_default.watch(corpus.paths.inboxDir, {
-    ignoreInitial: true,
-    depth: 0,
-    awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
-  });
-  watcher.on("add", () => void runDrain());
-  await runDrain();
-  return {
-    close: async () => {
-      await watcher.close();
-      index.close();
-    }
-  };
-}
-
-// src/clientRegistration.ts
-import { execFile as execFile2 } from "child_process";
-import { readFile as readFile2, stat as stat5, writeFile as writeFile2 } from "fs/promises";
-import { homedir as homedir2, platform as platform2 } from "os";
-import { dirname as dirname4, join as join4 } from "path";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
-var SERVER_NAME = "llmnesia";
-var realClaudeCli = {
-  detect: async () => {
-    try {
-      await execFileAsync2(process.platform === "win32" ? "where" : "which", ["claude"]);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  add: async (name, serve) => {
-    await execFileAsync2("claude", ["mcp", "add", name, "--", serve.command, ...serve.args]);
-  },
-  remove: async (name) => {
-    await execFileAsync2("claude", ["mcp", "remove", name]);
-  }
-};
-function paths(home2, osPlatform2) {
-  const claudeDesktop = osPlatform2 === "darwin" ? join4(home2, "Library", "Application Support", "Claude", "claude_desktop_config.json") : osPlatform2 === "win32" ? join4(process.env.APPDATA || join4(home2, "AppData", "Roaming"), "Claude", "claude_desktop_config.json") : null;
-  return {
-    claudeDesktop,
-    cursor: join4(home2, ".cursor", "mcp.json"),
-    codex: join4(home2, ".codex", "config.toml")
-  };
-}
-async function readJsonFile(path) {
-  let raw;
-  try {
-    raw = await readFile2(path, "utf8");
-  } catch (err) {
-    if (isErrnoException(err) && err.code === "ENOENT") {
-      return { data: {}, existed: false };
-    }
-    throw new Error(`Could not read ${path}: ${errorMessage(err)}`, { cause: err });
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("the top-level value must be a JSON object");
-    }
-    return { data: parsed, existed: true };
-  } catch (err) {
-    throw new Error(`Could not parse ${path}: ${errorMessage(err)}. The file was left unchanged.`, { cause: err });
-  }
-}
-function isErrnoException(value) {
-  return value instanceof Error && "code" in value;
-}
-function errorMessage(value) {
-  return value instanceof Error ? value.message : String(value);
-}
-async function clientDirExists(configPath) {
-  try {
-    return (await stat5(dirname4(configPath))).isDirectory();
-  } catch {
+  VERSION
+} from "./chunk-BQM5Q4XX.js";
+
+// src/nodeVersion.ts
+var MINIMUM_NODE_VERSION = "22.13.0";
+function numericParts(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+function supportsNodeVersion(version) {
+  const actual = numericParts(version);
+  const minimum = numericParts(MINIMUM_NODE_VERSION);
+  if (!actual || !minimum) {
     return false;
   }
-}
-async function registerClaudeCode(serve, cli) {
-  const present = await cli.detect();
-  if (!present) {
-    return { client: "Claude Code", action: "skipped", detail: "`claude` not found on PATH." };
-  }
-  try {
-    await cli.add(SERVER_NAME, serve);
-    return {
-      client: "Claude Code",
-      action: "registered",
-      detail: `Ran: claude mcp add ${SERVER_NAME} -- ${serve.command} ${serve.args.join(" ")}`
-    };
-  } catch (err) {
-    return {
-      client: "Claude Code",
-      action: "error",
-      detail: `claude mcp add failed: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-}
-async function registerJsonClient(clientLabel, configPath, serve, confirm, now) {
-  if (!await clientDirExists(configPath)) {
-    return {
-      client: clientLabel,
-      action: "skipped",
-      detail: `Not installed (no ${dirname4(configPath)}). Re-run install after setting it up.`
-    };
-  }
-  let data;
-  let existed;
-  try {
-    ({ data, existed } = await readJsonFile(configPath));
-  } catch (err) {
-    return { client: clientLabel, action: "error", detail: errorMessage(err) };
-  }
-  const servers = data.mcpServers && typeof data.mcpServers === "object" ? data.mcpServers : {};
-  const already = servers[SERVER_NAME];
-  const nextEntry = { command: serve.command, args: serve.args };
-  if (already && JSON.stringify(already) === JSON.stringify(nextEntry)) {
-    return { client: clientLabel, action: "skipped", detail: `Already registered at ${configPath}.` };
-  }
-  const preview = JSON.stringify({ mcpServers: { ...servers, [SERVER_NAME]: nextEntry } }, null, 2);
-  const message = existed ? `${clientLabel}: update ${configPath} to add the "${SERVER_NAME}" MCP server?
-${preview}` : `${clientLabel}: create ${configPath} with the "${SERVER_NAME}" MCP server?
-${preview}`;
-  const ok = await confirm(message);
-  if (!ok) {
-    return { client: clientLabel, action: "declined", detail: `Skipped by user. Config: ${configPath}` };
-  }
-  if (existed) {
-    const backupPath = `${configPath}.bak-${now()}`;
-    await writeFile2(backupPath, JSON.stringify(data, null, 2), "utf8");
-  }
-  const nextData = { ...data, mcpServers: { ...servers, [SERVER_NAME]: nextEntry } };
-  await writeFile2(configPath, `${JSON.stringify(nextData, null, 2)}
-`, "utf8");
-  return { client: clientLabel, action: "registered", detail: `Wrote ${configPath}.` };
-}
-function codexBlock(serve) {
-  const argsToml = serve.args.map((a) => JSON.stringify(a)).join(", ");
-  return `[mcp_servers.${SERVER_NAME}]
-command = ${JSON.stringify(serve.command)}
-args = [${argsToml}]
-`;
-}
-function genericBlock(serve) {
-  return JSON.stringify({ mcpServers: { [SERVER_NAME]: { command: serve.command, args: serve.args } } }, null, 2);
-}
-async function registerClients(options) {
-  const home2 = options.home ?? homedir2();
-  const osPlatform2 = options.osPlatform ?? platform2();
-  const now = options.now ?? (() => Date.now());
-  const { claudeDesktop, cursor, codex } = paths(home2, osPlatform2);
-  const results = [];
-  results.push(await registerClaudeCode(options.serve, options.claudeCli ?? realClaudeCli));
-  if (claudeDesktop) {
-    results.push(await registerJsonClient("Claude Desktop", claudeDesktop, options.serve, options.confirm, now));
-  }
-  results.push(await registerJsonClient("Cursor", cursor, options.serve, options.confirm, now));
-  results.push({
-    client: "Codex",
-    action: "printed",
-    detail: `Add this to ${codex} yourself (TOML is fragile to auto-edit):
-${codexBlock(options.serve)}`
-  });
-  results.push({
-    client: "Other MCP clients (Windsurf, Zed, LM Studio, ...)",
-    action: "printed",
-    detail: `Any client that accepts a stdio command+args block can use:
-${genericBlock(options.serve)}`
-  });
-  return results;
-}
-async function unregisterClaudeCode(cli) {
-  const present = await cli.detect();
-  if (!present) {
-    return { client: "Claude Code", action: "skipped", detail: "`claude` not found on PATH." };
-  }
-  try {
-    await cli.remove(SERVER_NAME);
-    return { client: "Claude Code", action: "registered", detail: `Ran: claude mcp remove ${SERVER_NAME}` };
-  } catch (err) {
-    return {
-      client: "Claude Code",
-      action: "error",
-      detail: `claude mcp remove failed (may already be unregistered): ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-}
-async function unregisterJsonClient(clientLabel, configPath, now) {
-  let data;
-  let existed;
-  try {
-    ({ data, existed } = await readJsonFile(configPath));
-  } catch (err) {
-    return { client: clientLabel, action: "error", detail: errorMessage(err) };
-  }
-  if (!existed) {
-    return { client: clientLabel, action: "skipped", detail: `No ${configPath}.` };
-  }
-  const servers = data.mcpServers && typeof data.mcpServers === "object" ? data.mcpServers : {};
-  if (!(SERVER_NAME in servers)) {
-    return { client: clientLabel, action: "skipped", detail: `Not registered in ${configPath}.` };
-  }
-  const backupPath = `${configPath}.bak-${now()}`;
-  await writeFile2(backupPath, JSON.stringify(data, null, 2), "utf8");
-  const { [SERVER_NAME]: _removed, ...rest } = servers;
-  const nextData = { ...data, mcpServers: rest };
-  await writeFile2(configPath, `${JSON.stringify(nextData, null, 2)}
-`, "utf8");
-  return { client: clientLabel, action: "registered", detail: `Removed from ${configPath} (backup: ${backupPath}).` };
-}
-async function unregisterClients(options = {}) {
-  const home2 = options.home ?? homedir2();
-  const osPlatform2 = options.osPlatform ?? platform2();
-  const now = options.now ?? (() => Date.now());
-  const { claudeDesktop, cursor } = paths(home2, osPlatform2);
-  const results = [await unregisterClaudeCode(options.claudeCli ?? realClaudeCli)];
-  if (claudeDesktop) {
-    results.push(await unregisterJsonClient("Claude Desktop", claudeDesktop, now));
-  }
-  results.push(await unregisterJsonClient("Cursor", cursor, now));
-  results.push({
-    client: "Codex / other MCP clients",
-    action: "skipped",
-    detail: "These were only ever printed as copy-paste blocks, never auto-edited \u2014 remove the block yourself if you added it."
-  });
-  return results;
-}
-
-// src/doctor.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { delimiter, dirname as dirname6, isAbsolute as isAbsolute2, join as join6, sep } from "path";
-import { homedir as homedir4, platform as platform3 } from "os";
-
-// src/runtimeInstall.ts
-import { cp, mkdir as mkdir2, readdir as readdir3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
-import { existsSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname5, join as join5 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function defaultSourceDir() {
-  return dirname5(fileURLToPath2(import.meta.url));
-}
-function runtimeBinDir(home2 = homedir3()) {
-  return join5(home2, ".llmnesia", "bin");
-}
-async function installRuntime(options = {}) {
-  const home2 = options.home ?? homedir3();
-  const sourceDir = options.sourceDir ?? defaultSourceDir();
-  const nodePath = options.nodePath ?? process.execPath;
-  const binDir = runtimeBinDir(home2);
-  const sourceEntry = join5(sourceDir, "cli.js");
-  if (!existsSync(sourceEntry)) {
-    throw new Error(
-      `Cannot locate the built runtime: no cli.js in ${sourceDir}. Run this from an installed package (npx @llmnesia/mcp install) or build first (npm run build).`
-    );
-  }
-  await rm2(binDir, { recursive: true, force: true });
-  await mkdir2(binDir, { recursive: true });
-  for (const name of await readdir3(sourceDir)) {
-    await cp(join5(sourceDir, name), join5(binDir, name), { recursive: true });
-  }
-  await writeFile3(
-    join5(binDir, "package.json"),
-    `${JSON.stringify(
-      {
-        name: "llmnesia-mcp-runtime",
-        private: true,
-        type: "module",
-        comment: "Installed copy of @llmnesia/mcp's dist. Managed by `llmnesia-mcp install`; edits are lost on reinstall."
-      },
-      null,
-      2
-    )}
-`,
-    "utf8"
-  );
-  const entry = join5(binDir, "cli.js");
-  return {
-    binDir,
-    entry,
-    serve: { command: nodePath, args: [entry, "serve"] },
-    sourceDir,
-    nodePath
-  };
-}
-async function uninstallRuntime(home2 = homedir3()) {
-  const binDir = runtimeBinDir(home2);
-  if (!existsSync(binDir)) {
-    return null;
-  }
-  await rm2(binDir, { recursive: true, force: true });
-  return binDir;
-}
-
-// src/doctor.ts
-function checkNativeHostManifest(home2, osPlatform2) {
-  if (osPlatform2 === "win32") {
-    const manifestPath = join6(home2, ".llmnesia", `${HOST_NAME}.json`);
-    if (existsSync2(manifestPath)) {
-      return {
-        name: "Native messaging host",
-        status: "ok",
-        detail: `Manifest present at ${manifestPath}. (This confirms the file the installer writes, not the registry key independently \u2014 re-run "install" if a browser still can't find it.)`
-      };
-    }
-    return {
-      name: "Native messaging host",
-      status: "missing",
-      detail: `No manifest at ${manifestPath}. Run: llmnesia-mcp install`
-    };
-  }
-  const found = [];
-  for (const [label, browserDir] of posixBrowsers(home2, osPlatform2)) {
-    if (!existsSync2(browserDir)) {
-      continue;
-    }
-    const manifestPath = join6(browserDir, "NativeMessagingHosts", `${HOST_NAME}.json`);
-    if (existsSync2(manifestPath)) {
-      found.push(label);
-    }
-  }
-  if (found.length > 0) {
-    return { name: "Native messaging host", status: "ok", detail: `Registered for: ${found.join(", ")}.` };
-  }
-  return {
-    name: "Native messaging host",
-    status: "missing",
-    detail: "No browser has the native-messaging manifest installed. Run: llmnesia-mcp install"
-  };
-}
-async function checkCorpus(home2, corpusRoot) {
-  const configPath = join6(home2, ".llmnesia", "config.json");
-  if (!corpusRoot && !existsSync2(configPath)) {
-    return {
-      name: "Corpus config",
-      status: "missing",
-      detail: `No ${configPath}. Run: llmnesia-mcp install`
-    };
-  }
-  const root = corpusRoot ?? resolveCorpusDir();
-  if (!existsSync2(root)) {
-    return {
-      name: "Corpus",
-      status: "warn",
-      detail: `Config points at ${root}, but that directory doesn't exist yet. It's created on first sync from your browser \u2014 open a chat and wait ~a minute. Normal right after installing.`
-    };
-  }
-  try {
-    const corpus = new Corpus(root);
-    const stats = await corpus.stats();
-    if (stats.conversationCount === 0) {
-      return {
-        name: "Corpus",
-        status: "warn",
-        detail: `Corpus at ${root} exists but is empty. It fills in as you chat, or on the browser extension's first backfill sync.`
-      };
-    }
-    return {
-      name: "Corpus",
-      status: "ok",
-      detail: `${stats.conversationCount} conversation(s), ${stats.messageCount} message(s) at ${root}.`
-    };
-  } catch (err) {
-    return {
-      name: "Corpus",
-      status: "warn",
-      detail: `Couldn't read corpus at ${root}: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-}
-function commandProblem(command, args = []) {
-  const looksLikePath = isAbsolute2(command) || command.includes(sep) || command.includes("/");
-  if (looksLikePath) {
-    if (!existsSync2(command)) {
-      return `its command does not exist: ${command}`;
-    }
-  } else if (!resolveOnPath(command)) {
-    return `its command "${command}" is not on PATH. GUI clients get a minimal PATH (no nvm, no homebrew), so a bare command name is unreliable even when your shell can find it. Re-run: llmnesia-mcp install`;
-  }
-  const script = args.find((a) => a.endsWith(".js") || a.endsWith(".mjs"));
-  if (script && (isAbsolute2(script) || script.includes(sep)) && !existsSync2(script)) {
-    return `its script does not exist: ${script}. Re-run: llmnesia-mcp install`;
-  }
-  return null;
-}
-function resolveOnPath(command) {
-  const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
-  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
-    if (!dir) {
-      continue;
-    }
-    for (const ext of exts) {
-      if (existsSync2(join6(dir, command + ext))) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function checkRuntime(home2) {
-  const entry = join6(runtimeBinDir(home2), "cli.js");
-  if (existsSync2(entry)) {
-    return { name: "MCP server runtime", status: "ok", detail: `Installed at ${entry}.` };
-  }
-  return {
-    name: "MCP server runtime",
-    status: "missing",
-    detail: `No runtime at ${entry}. Clients spawn this copy, so registration alone is not enough. Run: llmnesia-mcp install`
-  };
-}
-async function checkJsonClient(label, configPath) {
-  if (!existsSync2(dirname6(configPath))) {
-    return { name: label, status: "warn", detail: `Not installed (no ${dirname6(configPath)}).` };
-  }
-  if (!existsSync2(configPath)) {
-    return {
-      name: label,
-      status: "missing",
-      detail: `${label} is installed but has no MCP config yet. Run: llmnesia-mcp install`
-    };
-  }
-  try {
-    const data = JSON.parse(readFileSync(configPath, "utf8"));
-    const entry = data.mcpServers?.[SERVER_NAME];
-    if (!entry) {
-      return {
-        name: label,
-        status: "missing",
-        detail: `${label} is installed but not registered. Run: llmnesia-mcp install`
-      };
-    }
-    if (typeof entry.command !== "string") {
-      return { name: label, status: "missing", detail: `Registered in ${configPath} but the entry has no command. Run: llmnesia-mcp install` };
-    }
-    const args = Array.isArray(entry.args) ? entry.args.filter((a) => typeof a === "string") : [];
-    const problem = commandProblem(entry.command, args);
-    if (problem) {
-      return { name: label, status: "missing", detail: `Registered in ${configPath}, but ${problem}` };
+  for (let index = 0; index < minimum.length; index += 1) {
+    if (actual[index] !== minimum[index]) {
+      return actual[index] > minimum[index];
     }
-    return { name: label, status: "ok", detail: `Registered in ${configPath} and its command resolves.` };
-  } catch (err) {
-    return {
-      name: label,
-      status: "warn",
-      detail: `Found ${configPath} but couldn't parse it: ${err instanceof Error ? err.message : String(err)}`
-    };
   }
+  return true;
 }
-async function checkClaudeCode(cli) {
-  if (!await cli.detect()) {
-    return {
-      name: "Claude Code",
-      status: "warn",
-      detail: "`claude` not found on PATH \u2014 not installed, or not registered here yet."
-    };
-  }
-  const { execFile: execFile3 } = await import("child_process");
-  const { promisify: promisify3 } = await import("util");
-  const execFileAsync3 = promisify3(execFile3);
-  try {
-    const { stdout } = await execFileAsync3("claude", ["mcp", "list"]);
-    const line = stdout.split("\n").find((l) => l.trimStart().startsWith(`${SERVER_NAME}:`));
-    if (!line) {
-      return { name: "Claude Code", status: "missing", detail: "`claude` found but not registered. Run: llmnesia-mcp install" };
-    }
-    if (/✗|failed|error/i.test(line)) {
-      return { name: "Claude Code", status: "missing", detail: `Registered but not connecting \u2014 ${line.trim()}` };
-    }
-    return { name: "Claude Code", status: "ok", detail: `Registered: ${line.trim()}` };
-  } catch (err) {
-    return {
-      name: "Claude Code",
-      status: "warn",
-      detail: `\`claude mcp list\` failed: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-}
-function checkCodex(home2) {
-  const configPath = join6(home2, ".codex", "config.toml");
-  if (!existsSync2(configPath)) {
-    return { name: "Codex", status: "warn", detail: `Not installed (no ${configPath}), or never configured.` };
-  }
-  let text;
-  try {
-    text = readFileSync(configPath, "utf8");
-  } catch (err) {
-    return {
-      name: "Codex",
-      status: "warn",
-      detail: `Found ${configPath} but couldn't read it: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-  if (text.includes(`mcp_servers.${SERVER_NAME}`)) {
-    return { name: "Codex", status: "ok", detail: `Found in ${configPath}.` };
-  }
-  return {
-    name: "Codex",
-    status: "missing",
-    detail: `Codex is installed but not configured. llmnesia-mcp install prints the TOML block to add to ${configPath}.`
-  };
-}
-async function runDoctor(options = {}) {
-  const home2 = options.home ?? homedir4();
-  const osPlatform2 = options.osPlatform ?? platform3();
-  const claudeCli = options.claudeCli ?? realClaudeCli;
-  const claudeDesktopPath = osPlatform2 === "darwin" ? join6(home2, "Library", "Application Support", "Claude", "claude_desktop_config.json") : osPlatform2 === "win32" ? join6(process.env.APPDATA || join6(home2, "AppData", "Roaming"), "Claude", "claude_desktop_config.json") : null;
-  const checks = [];
-  const run = async (name, fn) => {
-    try {
-      checks.push(await fn());
-    } catch (err) {
-      checks.push({
-        name,
-        status: "warn",
-        detail: `Check failed unexpectedly: ${err instanceof Error ? err.message : String(err)}`
-      });
-    }
-  };
-  await run("Native messaging host", () => checkNativeHostManifest(home2, osPlatform2));
-  await run("MCP server runtime", () => checkRuntime(home2));
-  await run("Corpus", () => checkCorpus(home2, options.corpusRoot));
-  if (claudeDesktopPath) {
-    await run("Claude Desktop", () => checkJsonClient("Claude Desktop", claudeDesktopPath));
-  }
-  await run("Cursor", () => checkJsonClient("Cursor", join6(home2, ".cursor", "mcp.json")));
-  await run("Claude Code", () => checkClaudeCode(claudeCli));
-  await run("Codex", () => checkCodex(home2));
-  checks.push({
-    name: "Reminder",
-    status: "warn",
-    detail: "This can't detect whether you've restarted your browser or MCP client since installing \u2014 a fully quit-and-reopen is required for any of the above to take effect."
-  });
-  return { checks, allOk: checks.every((c) => c.status !== "missing") };
-}
-function formatDoctorReport(report) {
-  const icon = { ok: "\u2713", warn: "\u2022", missing: "\u2717" };
-  return report.checks.map((c) => `${icon[c.status]} ${c.name}: ${c.detail}`).join("\n");
-}
-
-// src/cli.ts
-var USAGE = `llmnesia-mcp ${VERSION}
+function unsupportedNodeMessage(version) {
+  return `LLMnesia MCP requires Node.js ${MINIMUM_NODE_VERSION} or newer, but this command is running on Node.js ${version}.
 
-Usage: llmnesia-mcp <command> [options]
+Install the current Node.js LTS release from https://nodejs.org/ and then run:
+  npx -y @llmnesia/mcp@latest install
 
-Setup:
-  install [ext-id...]  Install the native host + register this MCP server with
-                        detected clients (Claude Code/Desktop, Cursor, Codex, ...)
-  doctor                Diagnose: host installed? corpus present? clients wired?
-  uninstall             Remove native host + client registrations (never deletes
-                        your corpus \u2014 see the printed path if you want that too)
-  serve                 Run the MCP stdio server (what install registers with clients)
-
-Power-user / debugging:
-  init                 Create the corpus directory skeleton
-  ingest <file...>     Ingest one or more NDJSON backup files into the corpus
-  drain                Ingest every file in <corpus>/inbox, then archive them
-  watch                Watch <corpus>/inbox and ingest new deltas live
-  stats                Print corpus counts (conversations, messages, platforms)
-  reindex              Drop and rebuild the search index from the corpus
-  search <query>       Full-text search the corpus (BM25)
-
-Options:
-  -c, --corpus <dir>   Corpus root (default: $LLMNESIA_CORPUS_DIR or ~/.llmnesia/corpus)
-  -n, --limit <n>      search: max results (default 10)
-  --platform <name>    search: restrict to one platform
-  --title <substr>     search: title must contain this substring
-  --from <iso|ms>      search: only conversations created on/after this date
-  --to <iso|ms>        search: only conversations created on/before this date
-  --force              install: overwrite a differing corpus root in config.json
-  --yes, -y            install/uninstall: skip confirmation prompts
-  --version, -v        print the version and exit
+npx cannot install Node.js for you. If \`npx\` itself is not found, Node.js is not installed yet.
 `;
-function parseDate(value) {
-  if (!value) {
-    return void 0;
-  }
-  if (/^\d+$/.test(value)) {
-    return Number(value);
-  }
-  const ms = Date.parse(value);
-  return Number.isNaN(ms) ? void 0 : ms;
 }
-async function promptConfirm(message) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    process.stdout.write(`
-${message}
-`);
-    const answer = await rl.question("Proceed? [y/N] ");
-    return /^y(es)?$/i.test(answer.trim());
-  } finally {
-    rl.close();
-  }
-}
-function printRegistrationResults(results) {
-  for (const r of results) {
-    const icon = r.action === "registered" ? "\u2713" : r.action === "error" ? "\u2717" : "\u2022";
-    process.stdout.write(`${icon} ${r.client}: ${r.detail}
-
-`);
-  }
-}
-async function runInstall(positionals, options, flags) {
-  const skipConfirm = flags.has("yes");
-  process.stdout.write("Installing native messaging host\u2026\n");
-  try {
-    await installNativeHost({ ids: positionals, corpus: options.corpus, force: flags.has("force") });
-  } catch (err) {
-    process.stderr.write(`
-Native host install failed: ${err instanceof Error ? err.message : String(err)}
-`);
-    process.stderr.write("Continuing to register MCP clients anyway \u2014 the server itself doesn't need a browser.\n");
-  }
-  process.stdout.write("\nInstalling the MCP server runtime\u2026\n");
-  const runtime = await installRuntime();
-  process.stdout.write(`Installed to ${runtime.binDir} (running on ${runtime.nodePath})
-`);
-  process.stdout.write("\nRegistering MCP clients\u2026\n\n");
-  const confirm = skipConfirm ? async () => true : promptConfirm;
-  const results = await registerClients({ serve: runtime.serve, confirm });
-  printRegistrationResults(results);
-  process.stdout.write(
-    "Next step: fully quit and reopen your MCP client (and your browser, if you\nuse the extension). Reloading a window is not enough \u2014 the config is read\nonce at startup.\n\n"
-  );
-  process.stdout.write("Then run `llmnesia-mcp doctor` to check what's wired up.\n");
-  return 0;
-}
-async function runUninstall(flags) {
-  const skipConfirm = flags.has("yes");
-  if (!skipConfirm) {
-    const ok = await promptConfirm(
-      "This removes the native-messaging host and MCP client registrations. Your corpus (conversation data) is never deleted by this command."
-    );
-    if (!ok) {
-      process.stdout.write("Cancelled.\n");
-      return 0;
-    }
-  }
-  const hostResult = await uninstallNativeHost();
-  process.stdout.write(`Removed: ${hostResult.removed.length > 0 ? hostResult.removed.join(", ") : "(nothing to remove)"}
-`);
-  const removedRuntime = await uninstallRuntime();
-  process.stdout.write(`Removed runtime: ${removedRuntime ?? "(none installed)"}
 
-`);
-  const results = await unregisterClients();
-  printRegistrationResults(results);
-  if (hostResult.corpusRoot) {
-    process.stdout.write(
-      `Your corpus was NOT deleted \u2014 it's still at ${hostResult.corpusRoot}
-Delete it yourself if you want your data gone: rm -rf "${hostResult.corpusRoot}"
-`
-    );
-  }
-  return 0;
-}
-async function main() {
-  const { command, positionals, options, flags } = parseArgs(process.argv.slice(2));
-  if (flags.has("version")) {
+// src/bootstrap.ts
+async function bootstrap() {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--version") || argv.includes("-v")) {
     process.stdout.write(`${VERSION}
 `);
     return 0;
   }
-  if (flags.has("help")) {
-    process.stdout.write(USAGE);
-    return 0;
-  }
-  const root = resolveCorpusDir(options.corpus);
-  const corpus = new Corpus(root);
-  switch (command) {
-    case void 0:
-    case "help":
-      process.stdout.write(USAGE);
-      return 0;
-    case "install":
-      return runInstall(positionals, options, flags);
-    case "uninstall":
-      return runUninstall(flags);
-    case "doctor": {
-      const report = await runDoctor();
-      process.stdout.write(`${formatDoctorReport(report)}
-`);
-      return report.allOk ? 0 : 1;
-    }
-    case "serve": {
-      const { runServe } = await import("./mcp.js");
-      await runServe();
-      return 0;
-    }
-    case "init": {
-      await corpus.init();
-      process.stdout.write(`Initialized corpus at ${root}
-`);
-      return 0;
-    }
-    case "ingest": {
-      if (positionals.length === 0) {
-        process.stderr.write("ingest: expected at least one file path\n");
-        return 2;
-      }
-      await corpus.init();
-      let created = 0;
-      let updated = 0;
-      let skipped = 0;
-      let conversations = 0;
-      let malformed = 0;
-      for (const file of positionals) {
-        const report = await ingestFile(corpus, file);
-        created += report.created;
-        updated += report.updated;
-        skipped += report.skipped;
-        conversations += report.conversations;
-        malformed += report.malformedLines;
-      }
-      await corpus.touchIngestMeta();
-      process.stdout.write(
-        `Ingested ${conversations} conversation(s): ${created} created, ${updated} updated, ${skipped} unchanged` + (malformed > 0 ? `, ${malformed} malformed line(s) skipped` : "") + `
-`
-      );
-      return 0;
-    }
-    case "drain": {
-      const index = await openSearchIndex(corpus);
-      try {
-        const report = await drainInbox(corpus, index, {
-          onFileError: (name, error) => process.stderr.write(`  ! ${name}: ${error instanceof Error ? error.message : String(error)}
-`)
-        });
-        process.stdout.write(
-          `Drained ${report.files} inbox file(s): ${report.conversations} conversation(s) \u2014 ${report.created} created, ${report.updated} updated, ${report.skipped} unchanged` + (report.failed > 0 ? `, ${report.failed} file(s) failed` : "") + `
-`
-        );
-      } finally {
-        index.close();
-      }
-      return 0;
-    }
-    case "watch": {
-      process.stdout.write(`Watching ${corpus.paths.inboxDir} for new deltas (Ctrl+C to stop)\u2026
-`);
-      const handle = await watchInbox(corpus, (s) => {
-        process.stdout.write(
-          `Ingested ${s.files} file(s): ${s.created} created, ${s.updated} updated, ${s.skipped} unchanged
-`
-        );
-      });
-      await new Promise((resolve4) => {
-        const stop = () => {
-          void handle.close().then(resolve4);
-        };
-        process.once("SIGINT", stop);
-        process.once("SIGTERM", stop);
-      });
-      return 0;
-    }
-    case "stats": {
-      const stats = await corpus.stats();
-      const platforms = Object.entries(stats.byPlatform).sort((a, b) => b[1] - a[1]).map(([p, n]) => `    ${p}: ${n}`).join("\n");
-      process.stdout.write(
-        `Corpus: ${root}
-  conversations: ${stats.conversationCount}
-  messages:      ${stats.messageCount}
-` + (platforms ? `  by platform:
-${platforms}
-` : "")
-      );
-      return 0;
-    }
-    case "reindex": {
-      await corpus.init();
-      await deleteIndexDb(corpus.paths.indexDbFile);
-      const index = new SearchIndex(corpus.paths.indexDbFile);
-      try {
-        const { conversations } = await index.rebuildFrom(corpus);
-        process.stdout.write(`Rebuilt index: ${conversations} conversation(s)
-`);
-      } finally {
-        index.close();
-      }
-      return 0;
-    }
-    case "search": {
-      const query = positionals.join(" ").trim();
-      if (!query) {
-        process.stderr.write("search: expected a query\n");
-        return 2;
-      }
-      const filters = {
-        platform: options.platform || void 0,
-        title: options.title || void 0,
-        dateFrom: parseDate(options.from),
-        dateTo: parseDate(options.to),
-        limit: options.limit ? Number(options.limit) : void 0
-      };
-      const index = await openSearchIndex(corpus);
-      try {
-        const hits = index.search(query, filters);
-        if (hits.length === 0) {
-          process.stdout.write("No matches.\n");
-          return 0;
-        }
-        for (const hit of hits) {
-          const when = new Date(hit.createdAt).toISOString().slice(0, 10);
-          const where = hit.matchRole === "title" ? "title" : `${hit.matchRole} #${hit.matchMsgIndex}`;
-          process.stdout.write(
-            `${hit.pinned ? "\u2605 " : ""}${hit.title}  [${hit.platform} \xB7 ${when} \xB7 score ${hit.score.toFixed(2)}]
-  ${hit.docId}
-  ${collapse(hit.snippet)}  (${where})
-
-`
-          );
-        }
-      } finally {
-        index.close();
-      }
-      return 0;
-    }
-    default:
-      process.stderr.write(`Unknown command: ${command}
-
-${USAGE}`);
-      return 2;
+  if (!supportsNodeVersion(process.versions.node)) {
+    process.stderr.write(unsupportedNodeMessage(process.versions.node));
+    return 1;
   }
+  const { main } = await import("./cli-CNIF4XT3.js");
+  return main();
 }
-function collapse(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-main().then((code) => {
+bootstrap().then((code) => {
   process.exitCode = code;
 }).catch((err) => {
   process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
 `);
   process.exitCode = 1;
 });
-/*! Bundled license information:
-
-chokidar/esm/index.js:
-  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
-*/
-//# sourceMappingURL=cli.js.map