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

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

@@ -0,0 +1,105 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  estimateTokens
+} from "./chunk-TQNSPERU.js";
+
+// packages/coding-agent/dist/core/context-breakdown.js
+var CHARS_PER_TOKEN = 4, PROJECT_CONTEXT_RE = /<project_context>[\s\S]*?<\/project_context>/, PROJECT_INSTRUCTIONS_RE = /<project_instructions(?:\s+path="([^"]*)")?>([\s\S]*?)<\/project_instructions>/g, SKILLS_BLOCK_RE = /\n\nThe following skills provide specialized instructions for specific tasks\.[\s\S]*<\/available_skills>/;
+function estimateChars(text) {
+  return text.length === 0 ? 0 : Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function contextFileLabel(filePath, globalAgentsPath, modelAgentsPath) {
+  if (!filePath)
+    return "AGENTS.md";
+  let normalized = filePath.replace(/\\/g, "/");
+  if (globalAgentsPath && normalized.toLowerCase() === globalAgentsPath.replace(/\\/g, "/").toLowerCase())
+    return "Global AGENTS.md";
+  if (modelAgentsPath && normalized.toLowerCase() === modelAgentsPath.replace(/\\/g, "/").toLowerCase())
+    return `${normalized.split("/").at(-2) ?? "Model"} AGENTS.md`;
+  let slash = normalized.lastIndexOf("/");
+  return slash === -1 ? normalized : normalized.slice(slash + 1);
+}
+function splitSystemPromptSections(systemPrompt) {
+  let remaining = systemPrompt, contextFiles = [], contextMatch = remaining.match(PROJECT_CONTEXT_RE);
+  if (contextMatch) {
+    let block = contextMatch[0];
+    PROJECT_INSTRUCTIONS_RE.lastIndex = 0;
+    for (let match of block.matchAll(PROJECT_INSTRUCTIONS_RE))
+      contextFiles.push({
+        path: match[1],
+        content: match[2] ?? ""
+      });
+    remaining = remaining.replace(block, "");
+  }
+  let skills = "", skillsMatch = remaining.match(SKILLS_BLOCK_RE);
+  return skillsMatch && (skills = skillsMatch[0], remaining = remaining.replace(skills, "")), { base: remaining, contextFiles, skills };
+}
+function estimateToolDefinitionTokens(tools) {
+  let chars = 0;
+  for (let tool of tools) {
+    chars += tool.name.length + tool.description.length;
+    try {
+      let schema = JSON.stringify(tool.parameters);
+      schema && (chars += schema.length);
+    } catch {
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function computeContextBreakdown(input) {
+  let sections = splitSystemPromptSections(input.systemPrompt), systemPrompt = estimateChars(sections.base), contextFiles = sections.contextFiles.map((file) => ({
+    label: contextFileLabel(file.path, input.globalAgentsPath, input.modelAgentsPath),
+    path: file.path,
+    tokens: estimateChars(file.content)
+  })), skills = estimateChars(sections.skills), toolDefinitions = estimateToolDefinitionTokens(input.tools), user = 0, assistantText = 0, thinking = 0, toolCalls = 0, toolResults = 0, summaries = 0, counts = {
+    user: 0,
+    assistantText: 0,
+    thinking: 0,
+    toolCalls: 0,
+    toolResults: 0,
+    summaries: 0
+  };
+  for (let message of input.messages)
+    switch (message.role) {
+      case "assistant": {
+        let textChars = 0, thinkingChars = 0, toolCallChars = 0;
+        for (let block of message.content)
+          block.type === "text" ? textChars += block.text.length : block.type === "thinking" ? thinkingChars += block.thinking.length : block.type === "toolCall" && (toolCallChars += block.name.length + JSON.stringify(block.arguments).length);
+        assistantText += Math.ceil(textChars / CHARS_PER_TOKEN), thinking += Math.ceil(thinkingChars / CHARS_PER_TOKEN), toolCalls += Math.ceil(toolCallChars / CHARS_PER_TOKEN), textChars > 0 && counts.assistantText++, thinkingChars > 0 && counts.thinking++, toolCallChars > 0 && counts.toolCalls++;
+        break;
+      }
+      case "user":
+      case "custom":
+        user += estimateTokens(message), counts.user++;
+        break;
+      case "toolResult":
+      case "bashExecution":
+        toolResults += estimateTokens(message), counts.toolResults++;
+        break;
+      case "branchSummary":
+      case "compactionSummary":
+        summaries += estimateTokens(message), counts.summaries++;
+        break;
+    }
+  let contextFileTokens = contextFiles.reduce((sum, file) => sum + file.tokens, 0), total = systemPrompt + contextFileTokens + skills + toolDefinitions + user + assistantText + thinking + toolCalls + toolResults + summaries;
+  return {
+    systemPrompt,
+    contextFiles,
+    skills,
+    toolDefinitions,
+    user,
+    assistantText,
+    thinking,
+    toolCalls,
+    toolResults,
+    summaries,
+    total,
+    contextWindow: input.contextWindow,
+    free: Math.max(0, input.contextWindow - total),
+    counts
+  };
+}
+
+export {
+  computeContextBreakdown
+};

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

@@ -0,0 +1,342 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  loadPhoton
+} from "./chunk-RQ2Q5IYR.js";
+
+// packages/coding-agent/dist/utils/exif-orientation.js
+function readOrientationFromTiff(bytes, tiffStart) {
+  if (tiffStart + 8 > bytes.length)
+    return 1;
+  let le = (bytes[tiffStart] << 8 | bytes[tiffStart + 1]) === 18761, read16 = (pos) => le ? bytes[pos] | bytes[pos + 1] << 8 : bytes[pos] << 8 | bytes[pos + 1], ifdOffset = ((pos) => le ? bytes[pos] | bytes[pos + 1] << 8 | bytes[pos + 2] << 16 | bytes[pos + 3] << 24 : (bytes[pos] << 24 | bytes[pos + 1] << 16 | bytes[pos + 2] << 8 | bytes[pos + 3]) >>> 0)(tiffStart + 4), ifdStart = tiffStart + ifdOffset;
+  if (ifdStart + 2 > bytes.length)
+    return 1;
+  let entryCount = read16(ifdStart);
+  for (let i = 0; i < entryCount; i++) {
+    let entryPos = ifdStart + 2 + i * 12;
+    if (entryPos + 12 > bytes.length)
+      return 1;
+    if (read16(entryPos) === 274) {
+      let value = read16(entryPos + 8);
+      return value >= 1 && value <= 8 ? value : 1;
+    }
+  }
+  return 1;
+}
+function findJpegTiffOffset(bytes) {
+  let offset = 2;
+  for (; offset < bytes.length - 1; ) {
+    if (bytes[offset] !== 255)
+      return -1;
+    let marker = bytes[offset + 1];
+    if (marker === 255) {
+      offset++;
+      continue;
+    }
+    if (marker === 225) {
+      if (offset + 4 >= bytes.length)
+        return -1;
+      let segmentStart = offset + 4;
+      return segmentStart + 6 > bytes.length || !hasExifHeader(bytes, segmentStart) ? -1 : segmentStart + 6;
+    }
+    if (offset + 4 > bytes.length)
+      return -1;
+    let length = bytes[offset + 2] << 8 | bytes[offset + 3];
+    offset += 2 + length;
+  }
+  return -1;
+}
+function findWebpTiffOffset(bytes) {
+  let offset = 12;
+  for (; offset + 8 <= bytes.length; ) {
+    let chunkId = String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]), chunkSize = bytes[offset + 4] | bytes[offset + 5] << 8 | bytes[offset + 6] << 16 | bytes[offset + 7] << 24, dataStart = offset + 8;
+    if (chunkId === "EXIF")
+      return dataStart + chunkSize > bytes.length ? -1 : chunkSize >= 6 && hasExifHeader(bytes, dataStart) ? dataStart + 6 : dataStart;
+    offset = dataStart + chunkSize + chunkSize % 2;
+  }
+  return -1;
+}
+function hasExifHeader(bytes, offset) {
+  return bytes[offset] === 69 && bytes[offset + 1] === 120 && bytes[offset + 2] === 105 && bytes[offset + 3] === 102 && bytes[offset + 4] === 0 && bytes[offset + 5] === 0;
+}
+function getExifOrientation(bytes) {
+  let tiffOffset = -1;
+  return bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 216 ? tiffOffset = findJpegTiffOffset(bytes) : bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80 && (tiffOffset = findWebpTiffOffset(bytes)), tiffOffset === -1 ? 1 : readOrientationFromTiff(bytes, tiffOffset);
+}
+function rotate90(photon, image, dstIndex) {
+  let w = image.get_width(), h = image.get_height(), src = image.get_raw_pixels(), dst = new Uint8Array(src.length);
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++) {
+      let srcIdx = (y * w + x) * 4, dstIdx = dstIndex(x, y, w, h) * 4;
+      dst[dstIdx] = src[srcIdx], dst[dstIdx + 1] = src[srcIdx + 1], dst[dstIdx + 2] = src[srcIdx + 2], dst[dstIdx + 3] = src[srcIdx + 3];
+    }
+  return new photon.PhotonImage(dst, h, w);
+}
+function applyExifOrientation(photon, image, originalBytes) {
+  let orientation = getExifOrientation(originalBytes);
+  if (orientation === 1)
+    return image;
+  switch (orientation) {
+    case 2:
+      return photon.fliph(image), image;
+    case 3:
+      return photon.fliph(image), photon.flipv(image), image;
+    case 4:
+      return photon.flipv(image), image;
+    case 5: {
+      let rotated = rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+      return photon.fliph(rotated), rotated;
+    }
+    case 6:
+      return rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+    case 7: {
+      let rotated = rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+      return photon.fliph(rotated), rotated;
+    }
+    case 8:
+      return rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+    default:
+      return image;
+  }
+}
+
+// packages/coding-agent/dist/utils/image-convert.js
+async function convertImageBytesToPng(bytes) {
+  let photon = await loadPhoton();
+  if (!photon)
+    return null;
+  try {
+    let rawImage = photon.PhotonImage.new_from_byteslice(bytes), image = applyExifOrientation(photon, rawImage, bytes);
+    image !== rawImage && rawImage.free();
+    try {
+      return new Uint8Array(image.get_bytes());
+    } finally {
+      image.free();
+    }
+  } catch {
+    return null;
+  }
+}
+async function convertToPng(base64Data, mimeType) {
+  if (mimeType === "image/png")
+    return { data: base64Data, mimeType };
+  let bytes = new Uint8Array(Buffer.from(base64Data, "base64")), pngBytes = await convertImageBytesToPng(bytes);
+  return pngBytes ? {
+    data: Buffer.from(pngBytes).toString("base64"),
+    mimeType: "image/png"
+  } : null;
+}
+
+// packages/coding-agent/dist/utils/image-resize.js
+import { Worker } from "node:worker_threads";
+
+// packages/coding-agent/dist/utils/image-resize-core.js
+var DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024, DEFAULT_OPTIONS = {
+  maxWidth: 2e3,
+  maxHeight: 2e3,
+  maxBytes: DEFAULT_MAX_BYTES,
+  jpegQuality: 80
+};
+function encodeCandidate(buffer, mimeType) {
+  let data = Buffer.from(buffer).toString("base64");
+  return {
+    data,
+    encodedSize: Buffer.byteLength(data, "utf-8"),
+    mimeType
+  };
+}
+async function resizeImageInProcess(inputBytes, mimeType, options) {
+  let opts = { ...DEFAULT_OPTIONS, ...options }, inputBase64Size = Math.ceil(inputBytes.byteLength / 3) * 4, photon = await loadPhoton();
+  if (!photon)
+    return null;
+  let image;
+  try {
+    let tryEncodings = function(width, height, jpegQualities) {
+      let resized = photon.resize(image, width, height, photon.SamplingFilter.Lanczos3);
+      try {
+        let candidates = [encodeCandidate(resized.get_bytes(), "image/png")];
+        for (let quality of jpegQualities)
+          candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
+        return candidates;
+      } finally {
+        resized.free();
+      }
+    }, rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
+    image = applyExifOrientation(photon, rawImage, inputBytes), image !== rawImage && rawImage.free();
+    let originalWidth = image.get_width(), originalHeight = image.get_height(), format = mimeType.split("/")[1] ?? "png";
+    if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes)
+      return {
+        data: Buffer.from(inputBytes).toString("base64"),
+        mimeType: mimeType || `image/${format}`,
+        originalWidth,
+        originalHeight,
+        width: originalWidth,
+        height: originalHeight,
+        wasResized: !1
+      };
+    let targetWidth = originalWidth, targetHeight = originalHeight;
+    targetWidth > opts.maxWidth && (targetHeight = Math.round(targetHeight * opts.maxWidth / targetWidth), targetWidth = opts.maxWidth), targetHeight > opts.maxHeight && (targetWidth = Math.round(targetWidth * opts.maxHeight / targetHeight), targetHeight = opts.maxHeight);
+    let qualitySteps = Array.from(/* @__PURE__ */ new Set([opts.jpegQuality, 85, 70, 55, 40])), currentWidth = targetWidth, currentHeight = targetHeight;
+    for (; ; ) {
+      let candidates = tryEncodings(currentWidth, currentHeight, qualitySteps);
+      for (let candidate of candidates)
+        if (candidate.encodedSize < opts.maxBytes)
+          return {
+            data: candidate.data,
+            mimeType: candidate.mimeType,
+            originalWidth,
+            originalHeight,
+            width: currentWidth,
+            height: currentHeight,
+            wasResized: !0
+          };
+      if (currentWidth === 1 && currentHeight === 1)
+        break;
+      let nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75)), nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
+      if (nextWidth === currentWidth && nextHeight === currentHeight)
+        break;
+      currentWidth = nextWidth, currentHeight = nextHeight;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    image && image.free();
+  }
+}
+
+// packages/coding-agent/dist/utils/image-resize.js
+function toTransferableBytes(input) {
+  return new Uint8Array(input);
+}
+function isResizeImageWorkerResponse(value) {
+  return value !== null && typeof value == "object";
+}
+function createResizeWorker(workerSpecifier) {
+  return new Worker(workerSpecifier);
+}
+async function resizeImageInWorker(workerSpecifier, inputBytes, mimeType, options) {
+  let worker = createResizeWorker(workerSpecifier);
+  try {
+    let inputBytesForWorker = toTransferableBytes(inputBytes);
+    return await new Promise((resolve, reject) => {
+      let settled = !1, settle = (result) => {
+        settled || (settled = !0, resolve(result));
+      }, fail = (error) => {
+        settled || (settled = !0, reject(error));
+      };
+      worker.once("message", (message) => {
+        if (!isResizeImageWorkerResponse(message)) {
+          fail(new Error("Invalid image resize worker response"));
+          return;
+        }
+        if (message.error) {
+          fail(new Error(message.error));
+          return;
+        }
+        settle(message.result ?? null);
+      }), worker.once("error", fail), worker.once("exit", (code) => {
+        settled || fail(new Error(`Image resize worker exited with code ${code}`));
+      }), worker.postMessage({
+        inputBytes: inputBytesForWorker,
+        mimeType,
+        options
+      }, [inputBytesForWorker.buffer]);
+    });
+  } finally {
+    worker.terminate().catch(() => {
+    });
+  }
+}
+async function resizeImage(inputBytes, mimeType, options) {
+  let isTypeScriptRuntime = new URL("../utils/image-resize.js", import.meta.url).href.endsWith(".ts"), workerUrl = new URL(isTypeScriptRuntime ? "./image-resize-worker.ts" : "./image-resize-worker.js", new URL("../utils/image-resize.js", import.meta.url).href);
+  if (typeof process.versions.bun == "string")
+    try {
+      return await resizeImageInWorker("./src/utils/image-resize-worker.ts", inputBytes, mimeType, options);
+    } catch {
+    }
+  try {
+    return await resizeImageInWorker(workerUrl, inputBytes, mimeType, options);
+  } catch {
+    return resizeImageInProcess(inputBytes, mimeType, options);
+  }
+}
+function formatDimensionNote(result) {
+  if (!result.wasResized)
+    return;
+  let scale = result.originalWidth / result.width;
+  return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${result.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
+}
+
+// packages/coding-agent/dist/utils/image-process.js
+function baseMimeType(mimeType) {
+  return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
+}
+function normalizeSupportedImageMimeType(mimeType) {
+  switch (baseMimeType(mimeType)) {
+    case "image/png":
+      return "image/png";
+    case "image/jpeg":
+    case "image/jpg":
+      return "image/jpeg";
+    case "image/gif":
+      return "image/gif";
+    case "image/webp":
+      return "image/webp";
+    default:
+      return null;
+  }
+}
+async function normalizeImage(bytes, mimeType) {
+  let normalizedMimeType = normalizeSupportedImageMimeType(mimeType);
+  if (normalizedMimeType)
+    return { bytes, mimeType: normalizedMimeType };
+  let pngBytes = await convertImageBytesToPng(bytes);
+  return pngBytes ? {
+    bytes: pngBytes,
+    mimeType: "image/png",
+    convertedFrom: baseMimeType(mimeType)
+  } : null;
+}
+function conversionHint(from, to) {
+  if (!(!from || from === to))
+    return `[Image converted from ${from} to ${to}.]`;
+}
+async function processImage(bytes, mimeType, options) {
+  let autoResizeImages = options?.autoResizeImages ?? !0, normalized = await normalizeImage(bytes, mimeType);
+  if (!normalized)
+    return {
+      ok: !1,
+      message: "[Image omitted: could not be converted to a supported inline image format.]"
+    };
+  if (autoResizeImages) {
+    let resized = await resizeImage(normalized.bytes, normalized.mimeType, options?.resizeOptions);
+    if (!resized)
+      return {
+        ok: !1,
+        message: "[Image omitted: could not be resized below the inline image size limit.]"
+      };
+    let hints2 = [], convertedHint2 = conversionHint(normalized.convertedFrom, resized.mimeType);
+    convertedHint2 && hints2.push(convertedHint2);
+    let dimensionNote = formatDimensionNote(resized);
+    return dimensionNote && hints2.push(dimensionNote), {
+      ok: !0,
+      data: resized.data,
+      mimeType: resized.mimeType,
+      hints: hints2
+    };
+  }
+  let hints = [], convertedHint = conversionHint(normalized.convertedFrom, normalized.mimeType);
+  return convertedHint && hints.push(convertedHint), {
+    ok: !0,
+    data: Buffer.from(normalized.bytes).toString("base64"),
+    mimeType: normalized.mimeType,
+    hints
+  };
+}
+
+export {
+  convertToPng,
+  resizeImage,
+  formatDimensionNote,
+  processImage
+};

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

@@ -0,0 +1,64 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getModelTiersBridge,
+  registerModelTierBridge
+} from "./chunk-W3CVH5RX.js";
+import {
+  isRollbackSessionForceEnabled,
+  registerUsageServiceBridge
+} from "./chunk-YF63P5ZT.js";
+import {
+  registerCustomizeBridge
+} from "./chunk-HQCKFM2O.js";
+import {
+  registerMemoryCapBridge
+} from "./chunk-AY6CAJSL.js";
+
+// packages/coding-agent/dist/core/settings-tools-bridge.js
+var SETTINGS_TOOLS_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/settings-tools"), activeSettingsManager, sessionIdProvider;
+function manager() {
+  if (!activeSettingsManager)
+    throw new Error("Settings are unavailable in this runtime. Reload lunR and try again.");
+  return activeSettingsManager;
+}
+var bridge = {
+  getModelTiers: () => manager().getModelTiers(),
+  setModelTiers(update) {
+    let settings = manager();
+    update.enabled !== void 0 && settings.setModelTiersEnabled(update.enabled);
+    for (let tier of ["light", "standard", "heavy"]) {
+      let model = update[tier];
+      model !== void 0 && settings.setTierModel(tier, model);
+      let key = `${tier}Thinking`;
+      update[key] !== void 0 && settings.setTierThinking(tier, update[key] ?? void 0);
+    }
+  },
+  getAutoManageSubscriptions: () => manager().getAutoManageSubscriptions(),
+  setAutoManageSubscriptions: (enabled) => manager().setAutoManageSubscriptions(enabled),
+  getRollback: () => ({
+    enabled: manager().getRollbackEnabled(),
+    turns: manager().getRollbackTurns(),
+    capture: manager().getRollbackCapture(),
+    scope: manager().getRollbackScope(),
+    forcedByAuto: isRollbackSessionForceEnabled(sessionIdProvider?.())
+  }),
+  setRollback(update) {
+    let settings = manager();
+    update.enabled !== void 0 && settings.setRollbackEnabled(update.enabled), update.turns !== void 0 && settings.setRollbackTurns(update.turns), update.capture !== void 0 && settings.setRollbackCapture(update.capture), update.scope !== void 0 && settings.setRollbackScope(update.scope);
+  },
+  getSessionRetentionDays: () => manager().getSessionRetentionDays(),
+  setSessionRetentionDays: (days) => manager().setSessionRetentionDays(days)
+};
+function registerSettingsToolsBridge(settingsManager, getSessionId) {
+  activeSettingsManager = settingsManager, sessionIdProvider = getSessionId, globalThis[SETTINGS_TOOLS_BRIDGE_SYMBOL] = bridge;
+}
+
+// packages/coding-agent/dist/core/runtime-bridges.js
+function bindRuntimeBridges({ session, services }) {
+  let { settingsManager, modelRuntime } = services;
+  registerModelTierBridge(settingsManager), getModelTiersBridge()?.setParentThinkingProvider(() => session.thinkingLevel), registerMemoryCapBridge(settingsManager), registerCustomizeBridge(settingsManager), registerUsageServiceBridge(modelRuntime, settingsManager), registerSettingsToolsBridge(settingsManager, () => session.sessionId);
+}
+
+export {
+  bindRuntimeBridges
+};