@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

package/dist/node-runtime/chunk-PVCDKGR6.js

@@ -0,0 +1,55 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/timings.js
+var ENABLED = process.env.PI_TIMING === "1", timingNamespaces = /* @__PURE__ */ new Map(), importMainMs;
+function noteImportMain(ms) {
+  importMainMs = ms;
+}
+function resetTimings(namespace = "main") {
+  if (!ENABLED)
+    return;
+  let timings = namespace === "main" && importMainMs !== void 0 ? [{ label: "import:main", ms: importMainMs }] : [];
+  timingNamespaces.set(namespace, { timings, lastTime: Date.now() });
+}
+function time(label, namespace = "main") {
+  if (!ENABLED)
+    return;
+  let now = Date.now();
+  timingNamespaces.has(namespace) || resetTimings(namespace);
+  let timingNamespace = timingNamespaces.get(namespace);
+  timingNamespace.timings.push({ label, ms: now - timingNamespace.lastTime }), timingNamespace.lastTime = now;
+}
+async function measureStartup(label, operation, namespace = "extensions") {
+  if (!ENABLED)
+    return operation();
+  let started = performance.now();
+  try {
+    return await operation();
+  } finally {
+    timingNamespaces.has(namespace) || resetTimings(namespace), timingNamespaces.get(namespace).timings.push({ label, ms: performance.now() - started });
+  }
+}
+function printTimingGroup(title, timings) {
+  let printableTimings = timings.filter((timing) => timing.ms >= 0);
+  if (printableTimings.length !== 0) {
+    console.error(`
+--- ${title} ---`);
+    for (let t of printableTimings)
+      console.error(`  ${t.label}: ${t.ms.toFixed(1)}ms`);
+    title.endsWith("main") && console.error(`  TOTAL: ${printableTimings.reduce((a, b) => a + b.ms, 0).toFixed(1)}ms`), console.error(`${"-".repeat(title.length + 8)}
+`);
+  }
+}
+function printTimings() {
+  if (ENABLED)
+    for (let [namespace, timingNamespace] of timingNamespaces)
+      printTimingGroup(`Startup Timings: ${namespace}`, timingNamespace.timings);
+}
+
+export {
+  noteImportMain,
+  resetTimings,
+  time,
+  measureStartup,
+  printTimings
+};

package/dist/node-runtime/chunk-Q4Q6D4IY.js

@@ -0,0 +1,364 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  __commonJS,
+  __require
+} from "./chunk-BRJX2PRC.js";
+
+// node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "node_modules/isexe/windows.js"(exports, module) {
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs = __require("fs");
+    function checkPathExt(path, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext || (pathext = pathext.split(";"), pathext.indexOf("") !== -1))
+        return !0;
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path.substr(-p.length).toLowerCase() === p)
+          return !0;
+      }
+      return !1;
+    }
+    function checkStat(stat, path, options) {
+      return !stat.isSymbolicLink() && !stat.isFile() ? !1 : checkPathExt(path, options);
+    }
+    function isexe(path, options, cb) {
+      fs.stat(path, function(er, stat) {
+        cb(er, er ? !1 : checkStat(stat, path, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs.statSync(path), path, options);
+    }
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "node_modules/isexe/mode.js"(exports, module) {
+    module.exports = isexe;
+    isexe.sync = sync;
+    var fs = __require("fs");
+    function isexe(path, options, cb) {
+      fs.stat(path, function(er, stat) {
+        cb(er, er ? !1 : checkStat(stat, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs.statSync(path), options);
+    }
+    function checkStat(stat, options) {
+      return stat.isFile() && checkMode(stat, options);
+    }
+    function checkMode(stat, options) {
+      var mod = stat.mode, uid = stat.uid, gid = stat.gid, myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid(), myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid(), u = parseInt("100", 8), g = parseInt("010", 8), o = parseInt("001", 8), ug = u | g, ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "node_modules/isexe/index.js"(exports, module) {
+    var fs = __require("fs"), core;
+    process.platform === "win32" || global.TESTING_WINDOWS ? core = require_windows() : core = require_mode();
+    module.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path, options, cb) {
+      if (typeof options == "function" && (cb = options, options = {}), !cb) {
+        if (typeof Promise != "function")
+          throw new TypeError("callback not provided");
+        return new Promise(function(resolve, reject) {
+          isexe(path, options || {}, function(er, is) {
+            er ? reject(er) : resolve(is);
+          });
+        });
+      }
+      core(path, options || {}, function(er, is) {
+        er && (er.code === "EACCES" || options && options.ignoreErrors) && (er = null, is = !1), cb(er, is);
+      });
+    }
+    function sync(path, options) {
+      try {
+        return core.sync(path, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES")
+          return !1;
+        throw er;
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS({
+  "node_modules/which/which.js"(exports, module) {
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys", path = __require("path"), COLON = isWindows ? ";" : ":", isexe = require_isexe(), getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" }), getPathInfo = (cmd, opt) => {
+      let colon = opt.colon || COLON, pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+        "").split(colon)
+      ], pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "", pathExt = isWindows ? pathExtExe.split(colon) : [""];
+      return isWindows && cmd.indexOf(".") !== -1 && pathExt[0] !== "" && pathExt.unshift(""), {
+        pathEnv,
+        pathExt,
+        pathExtExe
+      };
+    }, which = (cmd, opt, cb) => {
+      typeof opt == "function" && (cb = opt, opt = {}), opt || (opt = {});
+      let { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt), found = [], step = (i) => new Promise((resolve, reject) => {
+        if (i === pathEnv.length)
+          return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+        let ppRaw = pathEnv[i], pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw, pCmd = path.join(pathPart, cmd), p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        resolve(subStep(p, i, 0));
+      }), subStep = (p, i, ii) => new Promise((resolve, reject) => {
+        if (ii === pathExt.length)
+          return resolve(step(i + 1));
+        let ext = pathExt[ii];
+        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+          if (!er && is)
+            if (opt.all)
+              found.push(p + ext);
+            else
+              return resolve(p + ext);
+          return resolve(subStep(p, i, ii + 1));
+        });
+      });
+      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+    }, whichSync = (cmd, opt) => {
+      opt = opt || {};
+      let { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt), found = [];
+      for (let i = 0; i < pathEnv.length; i++) {
+        let ppRaw = pathEnv[i], pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw, pCmd = path.join(pathPart, cmd), p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        for (let j = 0; j < pathExt.length; j++) {
+          let cur = p + pathExt[j];
+          try {
+            if (isexe.sync(cur, { pathExt: pathExtExe }))
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+          } catch {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    };
+    module.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+// node_modules/path-key/index.js
+var require_path_key = __commonJS({
+  "node_modules/path-key/index.js"(exports, module) {
+    "use strict";
+    var pathKey = (options = {}) => {
+      let environment = options.env || process.env;
+      return (options.platform || process.platform) !== "win32" ? "PATH" : Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+    };
+    module.exports = pathKey;
+    module.exports.default = pathKey;
+  }
+});
+
+// node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+  "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
+    "use strict";
+    var path = __require("path"), which = require_which(), getPathKey = require_path_key();
+    function resolveCommandAttempt(parsed, withoutPathExt) {
+      let env = parsed.options.env || process.env, cwd = process.cwd(), hasCustomCwd = parsed.options.cwd != null, shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+      if (shouldSwitchCwd)
+        try {
+          process.chdir(parsed.options.cwd);
+        } catch {
+        }
+      let resolved;
+      try {
+        resolved = which.sync(parsed.command, {
+          path: env[getPathKey({ env })],
+          pathExt: withoutPathExt ? path.delimiter : void 0
+        });
+      } catch {
+      } finally {
+        shouldSwitchCwd && process.chdir(cwd);
+      }
+      return resolved && (resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved)), resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, !0);
+    }
+    module.exports = resolveCommand;
+  }
+});
+
+// node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+  "node_modules/cross-spawn/lib/util/escape.js"(exports, module) {
+    "use strict";
+    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+    function escapeCommand(arg) {
+      return arg = arg.replace(metaCharsRegExp, "^$1"), arg;
+    }
+    function escapeArgument(arg, doubleEscapeMetaChars) {
+      return arg = `${arg}`, arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"'), arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1"), arg = `"${arg}"`, arg = arg.replace(metaCharsRegExp, "^$1"), doubleEscapeMetaChars && (arg = arg.replace(metaCharsRegExp, "^$1")), arg;
+    }
+    module.exports.command = escapeCommand;
+    module.exports.argument = escapeArgument;
+  }
+});
+
+// node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+  "node_modules/shebang-regex/index.js"(exports, module) {
+    "use strict";
+    module.exports = /^#!(.*)/;
+  }
+});
+
+// node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+  "node_modules/shebang-command/index.js"(exports, module) {
+    "use strict";
+    var shebangRegex = require_shebang_regex();
+    module.exports = (string = "") => {
+      let match = string.match(shebangRegex);
+      if (!match)
+        return null;
+      let [path, argument] = match[0].replace(/#! ?/, "").split(" "), binary = path.split("/").pop();
+      return binary === "env" ? argument : argument ? `${binary} ${argument}` : binary;
+    };
+  }
+});
+
+// node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+  "node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs"), shebangCommand = require_shebang_command();
+    function readShebang(command) {
+      let buffer = Buffer.alloc(150), fd;
+      try {
+        fd = fs.openSync(command, "r"), fs.readSync(fd, buffer, 0, 150, 0), fs.closeSync(fd);
+      } catch {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module.exports = readShebang;
+  }
+});
+
+// node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS({
+  "node_modules/cross-spawn/lib/parse.js"(exports, module) {
+    "use strict";
+    var path = __require("path"), resolveCommand = require_resolveCommand(), escape = require_escape(), readShebang = require_readShebang(), isWin = process.platform === "win32", isExecutableRegExp = /\.(?:com|exe)$/i, isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    function detectShebang(parsed) {
+      parsed.file = resolveCommand(parsed);
+      let shebang = parsed.file && readShebang(parsed.file);
+      return shebang ? (parsed.args.unshift(parsed.file), parsed.command = shebang, resolveCommand(parsed)) : parsed.file;
+    }
+    function parseNonShell(parsed) {
+      if (!isWin)
+        return parsed;
+      let commandFile = detectShebang(parsed), needsShell = !isExecutableRegExp.test(commandFile);
+      if (parsed.options.forceShell || needsShell) {
+        let needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+        parsed.command = path.normalize(parsed.command), parsed.command = escape.command(parsed.command), parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        let shellCommand = [parsed.command].concat(parsed.args).join(" ");
+        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`], parsed.command = process.env.comspec || "cmd.exe", parsed.options.windowsVerbatimArguments = !0;
+      }
+      return parsed;
+    }
+    function parse(command, args, options) {
+      args && !Array.isArray(args) && (options = args, args = null), args = args ? args.slice(0) : [], options = Object.assign({}, options);
+      let parsed = {
+        command,
+        args,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args
+        }
+      };
+      return options.shell ? parsed : parseNonShell(parsed);
+    }
+    module.exports = parse;
+  }
+});
+
+// node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+  "node_modules/cross-spawn/lib/enoent.js"(exports, module) {
+    "use strict";
+    var isWin = process.platform === "win32";
+    function notFoundError(original, syscall) {
+      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: "ENOENT",
+        errno: "ENOENT",
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args
+      });
+    }
+    function hookChildProcess(cp, parsed) {
+      if (!isWin)
+        return;
+      let originalEmit = cp.emit;
+      cp.emit = function(name, arg1) {
+        if (name === "exit") {
+          let err = verifyENOENT(arg1, parsed);
+          if (err)
+            return originalEmit.call(cp, "error", err);
+        }
+        return originalEmit.apply(cp, arguments);
+      };
+    }
+    function verifyENOENT(status, parsed) {
+      return isWin && status === 1 && !parsed.file ? notFoundError(parsed.original, "spawn") : null;
+    }
+    function verifyENOENTSync(status, parsed) {
+      return isWin && status === 1 && !parsed.file ? notFoundError(parsed.original, "spawnSync") : null;
+    }
+    module.exports = {
+      hookChildProcess,
+      verifyENOENT,
+      verifyENOENTSync,
+      notFoundError
+    };
+  }
+});
+
+// node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+  "node_modules/cross-spawn/index.js"(exports, module) {
+    "use strict";
+    var cp = __require("child_process"), parse = require_parse(), enoent = require_enoent();
+    function spawn(command, args, options) {
+      let parsed = parse(command, args, options), spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+      return enoent.hookChildProcess(spawned, parsed), spawned;
+    }
+    function spawnSync(command, args, options) {
+      let parsed = parse(command, args, options), result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+      return result.error = result.error || enoent.verifyENOENTSync(result.status, parsed), result;
+    }
+    module.exports = spawn;
+    module.exports.spawn = spawn;
+    module.exports.sync = spawnSync;
+    module.exports._parse = parse;
+    module.exports._enoent = enoent;
+  }
+});
+
+export {
+  require_cross_spawn
+};

package/dist/node-runtime/chunk-Q5ZU2VRT.js

@@ -0,0 +1,83 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  clipboard,
+  isWaylandSession
+} from "./chunk-NUIFPZWX.js";
+
+// packages/coding-agent/dist/utils/clipboard.js
+import { execSync, spawn } from "child_process";
+import { platform } from "os";
+function copyToX11Clipboard(options) {
+  try {
+    execSync("xclip -selection clipboard", options);
+  } catch {
+    execSync("xsel --clipboard --input", options);
+  }
+}
+var MAX_OSC52_ENCODED_LENGTH = 1e5;
+function isRemoteSession(env = process.env) {
+  return !!(env.SSH_CONNECTION || env.SSH_CLIENT || env.MOSH_CONNECTION);
+}
+function emitOsc52(text) {
+  let encoded = Buffer.from(text).toString("base64");
+  return encoded.length > MAX_OSC52_ENCODED_LENGTH ? !1 : (process.stdout.write(`\x1B]52;c;${encoded}\x07`), !0);
+}
+async function readClipboardText() {
+  if (!clipboard)
+    return null;
+  try {
+    return await clipboard.getText() || null;
+  } catch {
+    return null;
+  }
+}
+async function copyToClipboard(text) {
+  let copied = !1, p = platform();
+  try {
+    clipboard && p !== "linux" && (await clipboard.setText(text), copied = !0);
+  } catch {
+  }
+  let remote = isRemoteSession();
+  if (copied && !remote)
+    return;
+  let options = { input: text, timeout: 5e3, stdio: ["pipe", "ignore", "ignore"] };
+  if (!copied)
+    try {
+      if (p === "darwin")
+        execSync("pbcopy", options), copied = !0;
+      else if (p === "win32")
+        execSync("clip", options), copied = !0;
+      else {
+        if (process.env.TERMUX_VERSION)
+          try {
+            execSync("termux-clipboard-set", options), copied = !0;
+          } catch {
+          }
+        if (!copied) {
+          let hasWaylandDisplay = !!process.env.WAYLAND_DISPLAY, hasX11Display = !!process.env.DISPLAY;
+          if (isWaylandSession() && hasWaylandDisplay)
+            try {
+              execSync("which wl-copy", { stdio: "ignore" });
+              let proc = spawn("wl-copy", [], { stdio: ["pipe", "ignore", "ignore"] });
+              proc.stdin.on("error", () => {
+              }), proc.stdin.write(text), proc.stdin.end(), proc.unref(), copied = !0;
+            } catch {
+              hasX11Display && (copyToX11Clipboard(options), copied = !0);
+            }
+          else hasX11Display && (copyToX11Clipboard(options), copied = !0);
+        }
+      }
+    } catch {
+    }
+  if (remote || !copied) {
+    let osc52Copied = emitOsc52(text);
+    copied = copied || osc52Copied;
+  }
+  if (!copied)
+    throw new Error("Failed to copy to clipboard");
+}
+
+export {
+  readClipboardText,
+  copyToClipboard
+};