@ashx-j/lunr 0.2.17 → 0.2.19

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

@@ -0,0 +1,126 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  sanitizeBinaryOutput
+} from "./chunk-CSFI6YXL.js";
+import {
+  resolvePath
+} from "./chunk-FQMM2EZ2.js";
+
+// packages/coding-agent/dist/core/tools/render-utils.js
+import * as os from "node:os";
+import { basename } from "node:path";
+import { pathToFileURL } from "node:url";
+import { getCapabilities, getImageDimensions, hyperlink, imageFallback } from "@ashx-j/lunr-tui";
+
+// packages/coding-agent/dist/utils/ansi.js
+function ansiRegex({ onlyFirst = !1 } = {}) {
+  let pattern = "(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))|[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+var regex = ansiRegex();
+function stripAnsi(value) {
+  if (typeof value != "string")
+    throw new TypeError(`Expected a \`string\`, got \`${typeof value}\``);
+  return !value.includes("\x1B") && !value.includes("\x9B") ? value : value.replace(regex, "");
+}
+
+// packages/coding-agent/dist/core/tools/render-utils.js
+function shortenPath(path) {
+  if (typeof path != "string")
+    return "";
+  let home = os.homedir();
+  return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+function linkPath(styledText, rawPath, cwd) {
+  if (!getCapabilities().hyperlinks)
+    return styledText;
+  let absolutePath = resolvePath(rawPath, cwd);
+  return hyperlink(styledText, pathToFileURL(absolutePath).href);
+}
+function str(value) {
+  return typeof value == "string" ? value : value == null ? "" : null;
+}
+function replaceTabs(text) {
+  return text.replace(/\t/g, "   ");
+}
+function normalizeDisplayText(text) {
+  return text.replace(/\r/g, "");
+}
+function getTextOutput(result, showImages) {
+  if (!result)
+    return "";
+  let textBlocks = result.content.filter((c) => c.type === "text"), imageBlocks = result.content.filter((c) => c.type === "image"), output = textBlocks.map((c) => sanitizeBinaryOutput(stripAnsi(c.text || "")).replace(/\r/g, "")).join(`
+`), caps = getCapabilities();
+  if (imageBlocks.length > 0 && (!caps.images || !showImages)) {
+    let imageIndicators = imageBlocks.map((img) => {
+      let mimeType = img.mimeType ?? "image/unknown", dims = img.data && img.mimeType ? getImageDimensions(img.data, img.mimeType) ?? void 0 : void 0;
+      return imageFallback(mimeType, dims);
+    }).join(`
+`);
+    output = output ? `${output}
+${imageIndicators}` : imageIndicators;
+  }
+  return output;
+}
+function invalidArgText(theme) {
+  return theme.fg("error", "[invalid arg]");
+}
+function toolGroupRole(continuation, followed) {
+  return !continuation && followed ? "first" : continuation && followed ? "middle" : continuation && !followed ? "last" : "singleton";
+}
+function toolGroupTree(context) {
+  return !context.expanded;
+}
+function formatGroupedCall(opts) {
+  let detail = opts.detail?.trim() ? opts.detail : "";
+  if (!((opts.tree ?? opts.compact === !0) && opts.role !== "singleton" && detail.length > 0))
+    return detail ? `${opts.dot} ${opts.title} ${detail}` : `${opts.dot} ${opts.title}`;
+  let branch = opts.role === "last" ? "\u2514\u2500" : "\u251C\u2500";
+  return opts.role === "first" ? `${opts.dot} ${opts.title}
+  ${branch} ${detail}` : `  ${branch} ${detail}`;
+}
+function toolStatusDot(state, theme) {
+  return theme.fg(state === "pending" ? "muted" : state, "\u25CF");
+}
+function toolStatusDotFromContext(context, theme) {
+  return toolStatusDot(context.isPartial ? "pending" : context.isError ? "error" : "success", theme);
+}
+function renderToolPath(rawPath, theme, cwd, options) {
+  if (rawPath === null)
+    return invalidArgText(theme);
+  let value = rawPath || options?.emptyFallback;
+  return value ? linkPath(theme.fg("accent", shortenPath(value)), value, cwd) : theme.fg("toolOutput", "...");
+}
+function renderToolFileName(rawPath, theme, cwd) {
+  if (rawPath === null)
+    return invalidArgText(theme);
+  if (!rawPath)
+    return theme.fg("toolOutput", "...");
+  let name = basename(rawPath) || rawPath;
+  return linkPath(theme.fg("accent", name), rawPath, cwd);
+}
+function renderCollapsedSearchPath(rawPath, theme, cwd) {
+  if (rawPath === null)
+    return invalidArgText(theme);
+  let value = rawPath.trim();
+  if (!(!value || value === "." || value === "./"))
+    return renderToolFileName(value, theme, cwd);
+}
+
+export {
+  stripAnsi,
+  shortenPath,
+  str,
+  replaceTabs,
+  normalizeDisplayText,
+  getTextOutput,
+  invalidArgText,
+  toolGroupRole,
+  toolGroupTree,
+  formatGroupedCall,
+  toolStatusDot,
+  toolStatusDotFromContext,
+  renderToolPath,
+  renderToolFileName,
+  renderCollapsedSearchPath
+};

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

@@ -0,0 +1,100 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  require_semver
+} from "./chunk-DVGWF6A2.js";
+import {
+  NPM_CLI_PACKAGE,
+  PACKAGE_NAME
+} from "./chunk-FQMM2EZ2.js";
+import {
+  __toESM
+} from "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/update-check.js
+var import_semver = __toESM(require_semver(), 1);
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var UPDATE_CHECK_TTL_MS = 1440 * 60 * 1e3, UPDATE_CHECK_TIMEOUT_MS = 4e3, NPM_LATEST_URL = `https://registry.npmjs.org/${NPM_CLI_PACKAGE}/latest`;
+function isPublishedInstall(packageName = PACKAGE_NAME, npmName = NPM_CLI_PACKAGE) {
+  return packageName === npmName;
+}
+function updateCheckPath(agentDir) {
+  return join(agentDir, "update-check.json");
+}
+function readRecord(path) {
+  try {
+    let raw = JSON.parse(readFileSync(path, "utf8"));
+    return typeof raw.checkedAt != "number" || typeof raw.latest != "string" || !raw.latest.trim() ? void 0 : {
+      checkedAt: raw.checkedAt,
+      latest: raw.latest.trim(),
+      notifiedVersion: typeof raw.notifiedVersion == "string" ? raw.notifiedVersion : void 0
+    };
+  } catch {
+    return;
+  }
+}
+function writeRecord(path, record) {
+  mkdirSync(dirname(path), { recursive: !0 }), writeFileSync(path, `${JSON.stringify(record)}
+`, "utf8");
+}
+async function fetchLatest(fetchImpl) {
+  let controller = new AbortController(), timeout = setTimeout(() => controller.abort(), UPDATE_CHECK_TIMEOUT_MS);
+  try {
+    let response = await fetchImpl(NPM_LATEST_URL, {
+      headers: { Accept: "application/json" },
+      signal: controller.signal
+    });
+    if (!response.ok)
+      return;
+    let payload = await response.json();
+    return typeof payload.version == "string" && payload.version.trim() ? payload.version.trim() : void 0;
+  } catch {
+    return;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function checkForUpdate(options) {
+  if (options.offline || !(options.published ?? isPublishedInstall()))
+    return;
+  let now = options.now ?? Date.now(), path = updateCheckPath(options.agentDir), record = existsSync(path) ? readRecord(path) : void 0;
+  if (!record || now - record.checkedAt >= UPDATE_CHECK_TTL_MS || options.force) {
+    let latest = await fetchLatest(options.fetchImpl ?? fetch);
+    if (!latest)
+      return record ? toResult(options.currentVersion, record, !1) : void 0;
+    record = { checkedAt: now, latest, notifiedVersion: record?.notifiedVersion };
+    try {
+      writeRecord(path, record);
+    } catch {
+    }
+  }
+  if (record)
+    return toResult(options.currentVersion, record, !0);
+}
+function isNewer(latest, current) {
+  try {
+    return (0, import_semver.gt)(latest, current);
+  } catch {
+    return !1;
+  }
+}
+function toResult(current, record, allowNotice) {
+  let newer = isNewer(record.latest, current), notice = allowNotice && newer && record.notifiedVersion !== record.latest ? `lunR ${record.latest} is available. Run lunr update.` : void 0;
+  return { latest: record.latest, current, newer, notice };
+}
+function markUpdateNotified(agentDir, latest) {
+  let path = updateCheckPath(agentDir), record = existsSync(path) ? readRecord(path) : void 0;
+  if (record) {
+    record.notifiedVersion = latest;
+    try {
+      writeRecord(path, record);
+    } catch {
+    }
+  }
+}
+
+export {
+  isPublishedInstall,
+  checkForUpdate,
+  markUpdateNotified
+};

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

@@ -0,0 +1,98 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/model-instructions.js
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from "node:fs";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+function getInstructionsRoot(agentDir) {
+  return join(resolve(agentDir), "agents");
+}
+function getGlobalInstructionsPath(agentDir) {
+  return join(getInstructionsRoot(agentDir), "AGENTS.md");
+}
+function modelInstructionFolderName(modelId) {
+  let withoutThinking = (modelId.trim().split(/[\\/]/).filter(Boolean).at(-1) ?? "model").replace(/:(?:off|minimal|low|medium|high|xhigh|max)$/i, ""), safe = withoutThinking.replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_").replace(/[. ]+$/g, "");
+  if ((!safe || safe === "." || safe === "..") && (safe = "model"), /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(safe) && (safe = `_${safe}`), safe.length > 100 || safe.toLowerCase() !== withoutThinking.toLowerCase()) {
+    let digest = createHash("sha256").update(withoutThinking.toLowerCase()).digest("hex").slice(0, 8);
+    safe = `${safe.slice(0, 90)}-${digest}`;
+  }
+  return safe.toLowerCase();
+}
+function getModelInstructionsPath(agentDir, modelId) {
+  return join(getInstructionsRoot(agentDir), modelInstructionFolderName(modelId), "AGENTS.md");
+}
+function isUserInstructionsPath(filePath, agentDir) {
+  let rel = relative(resolve(getInstructionsRoot(agentDir)), resolve(filePath));
+  return rel === "" || !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+function migrateLegacyGlobalInstructions(agentDir) {
+  let legacyPath = join(resolve(agentDir), "AGENTS.md"), destinationPath = getGlobalInstructionsPath(agentDir);
+  if (!existsSync(legacyPath))
+    return { status: "absent" };
+  if (existsSync(destinationPath))
+    return {
+      status: "conflict",
+      diagnostic: `Both legacy '${legacyPath}' and current '${destinationPath}' exist. Kept both and will use the current file.`
+    };
+  try {
+    return mkdirSync(getInstructionsRoot(agentDir), { recursive: !0 }), renameSync(legacyPath, destinationPath), { status: "migrated" };
+  } catch (error) {
+    return {
+      status: "failed",
+      diagnostic: `Could not migrate '${legacyPath}' to '${destinationPath}': ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function concreteModelId(value) {
+  if (typeof value != "string")
+    return;
+  let trimmed = value.trim();
+  if (!(!trimmed || /[*?{}]/.test(trimmed)))
+    return trimmed.replace(/:(?:off|minimal|low|medium|high|xhigh|max)$/i, "");
+}
+function ensureModelInstructionDirs(agentDir, settings, currentModel) {
+  let modelIds = /* @__PURE__ */ new Set(), add = (value) => {
+    let id = concreteModelId(value);
+    id && modelIds.add(id);
+  };
+  add(currentModel?.id), add(settings.defaultModel);
+  for (let value of settings.enabledModels ?? [])
+    add(value);
+  add(settings.modelTiers?.light), add(settings.modelTiers?.standard), add(settings.modelTiers?.heavy);
+  let diagnostics = [];
+  for (let id of modelIds)
+    try {
+      mkdirSync(join(getInstructionsRoot(agentDir), modelInstructionFolderName(id)), { recursive: !0 });
+    } catch (error) {
+      diagnostics.push(`Could not prepare model-instruction folder for '${id}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  return diagnostics;
+}
+function safeReadInstruction(path) {
+  try {
+    return !existsSync(path) || !statSync(path).isFile() ? void 0 : { path, content: readFileSync(path, "utf8") };
+  } catch {
+    return;
+  }
+}
+function loadSelectedUserInstructions(options) {
+  ensureModelInstructionDirs(options.agentDir, options.settingsManager.getGlobalSettings(), options.model);
+  let enabled = options.settingsManager.getModelInstructionsEnabled(), mode = options.settingsManager.getModelInstructionsMode(), files = [];
+  if (!enabled || mode === "both") {
+    let globalFile = safeReadInstruction(getGlobalInstructionsPath(options.agentDir));
+    globalFile && files.push(globalFile);
+  }
+  if (enabled && options.model) {
+    let modelFile = safeReadInstruction(getModelInstructionsPath(options.agentDir, options.model.id));
+    modelFile && files.push(modelFile);
+  }
+  return files;
+}
+
+export {
+  getGlobalInstructionsPath,
+  getModelInstructionsPath,
+  isUserInstructionsPath,
+  migrateLegacyGlobalInstructions,
+  loadSelectedUserInstructions
+};