@ashx-j/lunr-dev 0.2.16-dev.9.1 → 0.2.19-dev.10.1

package/dist/node-runtime/chunk-5OLJGVCB.js

@@ -0,0 +1,68 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/computer-use/policy.js
+var settingsListeners = /* @__PURE__ */ new Set();
+function computerSettingsChanged(settings) {
+  for (let listener of settingsListeners)
+    listener(settings);
+}
+function onComputerSettingsChanged(listener) {
+  return settingsListeners.add(listener), () => {
+    settingsListeners.delete(listener);
+  };
+}
+var COMPUTER_TOOLS = [
+  "computer_load",
+  "computer_apps",
+  "computer_observe",
+  "computer_click",
+  "computer_drag",
+  "computer_key",
+  "computer_text",
+  "computer_window",
+  "computer_launch",
+  "computer_scroll",
+  "computer_end"
+];
+function computerPolicy(name, input) {
+  if (name.startsWith("computer_"))
+    switch (name) {
+      case "computer_load":
+      case "computer_apps":
+      case "computer_observe":
+      case "computer_end":
+        return { observation: !0, foreground: !1 };
+      case "computer_click":
+      case "computer_drag":
+      case "computer_key":
+      case "computer_text":
+      case "computer_scroll":
+        return { observation: !1, foreground: input.foreground === !0 || input.desktop === !0 };
+      case "computer_window":
+      case "computer_launch":
+        return { observation: !1, foreground: !0 };
+      default:
+        throw new Error(`Unknown computer operation: ${name}`);
+    }
+}
+function computerRefusal(name, input, policy) {
+  let operation = computerPolicy(name, input);
+  if (!operation)
+    return "Unknown computer operation.";
+  if (policy.child)
+    return "Computer tools are available only to main agents.";
+  if (!policy.enabled)
+    return "Computer use is disabled in settings.";
+  if (operation.foreground && !policy.foreground)
+    return "Foreground control is disabled. Use background operations.";
+  if (!policy.vision && (name !== "computer_window" && (input.x !== void 0 || input.y !== void 0) || name === "computer_drag" || input.screenshot === !0 || input.desktop === !0))
+    return "This model cannot receive images. Use accessibility elements or select an image-capable model.";
+}
+
+export {
+  computerSettingsChanged,
+  onComputerSettingsChanged,
+  COMPUTER_TOOLS,
+  computerPolicy,
+  computerRefusal
+};

package/dist/node-runtime/chunk-5Q45AVQG.js

@@ -0,0 +1,108 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  applyExifOrientation,
+  formatDimensionNote,
+  resizeImage
+} from "./chunk-ZSEZY3II.js";
+import {
+  loadPhoton
+} from "./chunk-RQ2Q5IYR.js";
+
+// 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-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,
+  processImage
+};

package/dist/node-runtime/{chunk-TQNSPERU.js → chunk-5SQDLSZJ.js}

@@ -5,7 +5,7 @@ import {
 import {
   buildSessionContext,
   sessionEntryToContextMessages
-} from "./chunk-PBC2Y6GS.js";
+} from "./chunk-6UB6NKA3.js";
 import {
   convertToLlm,
   createBranchSummaryMessage,

package/dist/node-runtime/{chunk-F4VQFJI2.js → chunk-6SPPH4FY.js}

@@ -4,10 +4,7 @@ import {
   ServerError,
   logger,
   wrapError
-} from "./chunk-MKKH27PH.js";
-import {
-  UrlElicitationRequiredError
-} from "./chunk-4TLO4PO2.js";
+} from "./chunk-BKAZ6BKX.js";
 import {
   UI_STREAM_HOST_CONTEXT_KEY,
   UI_STREAM_REQUEST_META_KEY,
@@ -15,6 +12,9 @@ import {
   extractUiPromptText,
   getVisualizationStreamEnvelope
 } from "./chunk-ARC4KOTI.js";
+import {
+  UrlElicitationRequiredError
+} from "./chunk-2IDTZAG5.js";
 
 // packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/tool-registrar.js
 function transformMcpContent(content) {

package/dist/node-runtime/{chunk-PBC2Y6GS.js → chunk-6UB6NKA3.js}

@@ -73,12 +73,13 @@ function migrateSessionEntries(entries) {
 function parseSessionEntries(content) {
   let entries = [], lines = content.trim().split(`
 `);
-  for (let [index, line] of lines.entries()) {
-    if (!line.trim())
-      continue;
-    let entry = parseSessionEntryLine(line, `line ${index + 1}`);
-    entry && entries.push(entry);
-  }
+  for (let line of lines)
+    if (line.trim())
+      try {
+        let entry = JSON.parse(line);
+        entries.push(entry);
+      } catch {
+      }
   return entries;
 }
 function getLatestCompactionEntry(entries) {
@@ -87,40 +88,13 @@ function getLatestCompactionEntry(entries) {
       return entries[i];
   return null;
 }
-function validateSessionGraph(entries) {
+function buildEntryIndex(entries, byId) {
+  if (byId)
+    return byId;
   let index = /* @__PURE__ */ new Map();
-  for (let entry of entries) {
-    if (typeof entry.id != "string" || !entry.id)
-      throw new Error("Session graph is corrupt: every entry must have a non-empty id");
-    if (index.has(entry.id))
-      throw new Error(`Session graph is corrupt: duplicate entry id "${entry.id}"`);
+  for (let entry of entries)
     index.set(entry.id, entry);
-  }
-  for (let entry of entries) {
-    if (entry.parentId === entry.id)
-      throw new Error(`Session graph is corrupt: entry "${entry.id}" links to itself`);
-    if (entry.parentId !== null && !index.has(entry.parentId))
-      throw new Error(`Session graph is corrupt: entry "${entry.id}" has missing parent "${entry.parentId}"`);
-  }
-  let complete = /* @__PURE__ */ new Set();
-  for (let entry of entries) {
-    if (complete.has(entry.id))
-      continue;
-    let path = [], positions = /* @__PURE__ */ new Map(), current = entry;
-    for (; current && !complete.has(current.id); ) {
-      let position = positions.get(current.id);
-      if (position !== void 0) {
-        let cycle = [...path.slice(position), current.id].join(" -> ");
-        throw new Error(`Session graph is corrupt: parent cycle detected (${cycle})`);
-      }
-      positions.set(current.id, path.length), path.push(current.id), current = current.parentId === null ? void 0 : index.get(current.parentId);
-    }
-    for (let id of path)
-      complete.add(id);
-  }
-}
-function buildEntryIndex(entries, byId) {
-  return byId || (validateSessionGraph(entries), new Map(entries.map((entry) => [entry.id, entry])));
+  return index;
 }
 function buildSessionPath(entries, leafId, byId) {
   let index = buildEntryIndex(entries, byId), leaf;
@@ -128,14 +102,9 @@ function buildSessionPath(entries, leafId, byId) {
     return [];
   if (leafId && (leaf = index.get(leafId)), leaf ??= entries[entries.length - 1], !leaf)
     return [];
-  let path = [], visited = /* @__PURE__ */ new Set(), current = leaf;
-  for (; current; ) {
-    if (visited.has(current.id))
-      throw new Error(`Session graph is corrupt: parent cycle detected at entry "${current.id}"`);
-    if (visited.add(current.id), path.push(current), current.parentId && !index.has(current.parentId))
-      throw new Error(`Session graph is corrupt: entry "${current.id}" has missing parent "${current.parentId}"`);
-    current = current.parentId ? index.get(current.parentId) : void 0;
-  }
+  let path = [], current = leaf;
+  for (; current; )
+    path.push(current), current = current.parentId ? index.get(current.parentId) : void 0;
   return path.reverse(), path;
 }
 function getSessionContextSettings(path) {
@@ -182,14 +151,13 @@ function getDefaultSessionDir(cwd, agentDir = getAgentDir()) {
   return existsSync(sessionDir) || mkdirSync(sessionDir, { recursive: !0 }), sessionDir;
 }
 var SESSION_READ_BUFFER_SIZE = 1024 * 1024;
-function parseSessionEntryLine(line, location) {
-  let trimmed = line.replace(/\u0000/g, "").trim();
-  if (!trimmed)
+function parseSessionEntryLine(line) {
+  if (!line.trim())
     return null;
   try {
-    return JSON.parse(trimmed);
+    return JSON.parse(line);
   } catch {
-    throw new Error(location ? `Malformed session line ${location}` : "Malformed session line");
+    return null;
   }
 }
 function loadEntriesFromFile(filePath) {
@@ -198,7 +166,7 @@ function loadEntriesFromFile(filePath) {
     return [];
   let entries = [], fd = openSync(resolvedFilePath, "r");
   try {
-    let decoder = new StringDecoder("utf8"), buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE), pending = "", lineNumber = 0;
+    let decoder = new StringDecoder("utf8"), buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE), pending = "";
     for (; ; ) {
       let bytesRead = readSync(fd, buffer, 0, buffer.length, null);
       if (bytesRead === 0)
@@ -207,18 +175,15 @@ function loadEntriesFromFile(filePath) {
       let lineStart = 0, newlineIndex = pending.indexOf(`
 `, lineStart);
       for (; newlineIndex !== -1; ) {
-        lineNumber++;
-        let entry = parseSessionEntryLine(pending.slice(lineStart, newlineIndex), `in ${resolvedFilePath}:${lineNumber}`);
+        let entry = parseSessionEntryLine(pending.slice(lineStart, newlineIndex));
         entry && entries.push(entry), lineStart = newlineIndex + 1, newlineIndex = pending.indexOf(`
 `, lineStart);
       }
       pending = pending.slice(lineStart);
     }
-    if (pending += decoder.end(), pending.trim()) {
-      lineNumber++;
-      let finalEntry = parseSessionEntryLine(pending, `in ${resolvedFilePath}:${lineNumber}`);
-      finalEntry && entries.push(finalEntry);
-    }
+    pending += decoder.end();
+    let finalEntry = parseSessionEntryLine(pending);
+    finalEntry && entries.push(finalEntry);
   } finally {
     closeSync(fd);
   }
@@ -381,9 +346,7 @@ var SessionManager = class _SessionManager {
         return;
       }
       let header = this.fileEntries.find((e) => e.type === "session");
-      if (!header)
-        throw new Error(`Session file is not a valid pi session: ${this.sessionFile}`);
-      this.sessionId = header.id, migrateToCurrentVersion(this.fileEntries) && this._rewriteFile(), this._buildIndex(), this.flushed = !0;
+      this.sessionId = header?.id ?? createSessionId(), migrateToCurrentVersion(this.fileEntries) && this._rewriteFile(), this._buildIndex(), this.flushed = !0;
     } else {
       let explicitPath = this.sessionFile;
       this.newSession(), this.sessionFile = explicitPath;
@@ -406,7 +369,7 @@ var SessionManager = class _SessionManager {
     return this.sessionFile;
   }
   _buildIndex() {
-    validateSessionGraph(this.fileEntries.filter((entry) => entry.type !== "session")), this.byId.clear(), this.labelsById.clear(), this.labelTimestampsById.clear(), this.leafId = null;
+    this.byId.clear(), this.labelsById.clear(), this.labelTimestampsById.clear(), this.leafId = null;
     for (let entry of this.fileEntries)
       entry.type !== "session" && (this.byId.set(entry.id, entry), this.leafId = entry.id, entry.type === "label" && (entry.label ? (this.labelsById.set(entry.targetId, entry.label), this.labelTimestampsById.set(entry.targetId, entry.timestamp)) : (this.labelsById.delete(entry.targetId), this.labelTimestampsById.delete(entry.targetId))));
   }
@@ -624,14 +587,9 @@ var SessionManager = class _SessionManager {
    * Use buildSessionContext() to get the resolved messages for the LLM.
    */
   getBranch(fromId) {
-    let path = [], visited = /* @__PURE__ */ new Set(), startId = fromId ?? this.leafId, current = startId ? this.byId.get(startId) : void 0;
-    for (; current; ) {
-      if (visited.has(current.id))
-        throw new Error(`Session graph is corrupt: parent cycle detected at entry "${current.id}"`);
-      if (visited.add(current.id), path.push(current), current.parentId && !this.byId.has(current.parentId))
-        throw new Error(`Session graph is corrupt: entry "${current.id}" has missing parent "${current.parentId}"`);
-      current = current.parentId ? this.byId.get(current.parentId) : void 0;
-    }
+    let path = [], startId = fromId ?? this.leafId, current = startId ? this.byId.get(startId) : void 0;
+    for (; current; )
+      path.push(current), current = current.parentId ? this.byId.get(current.parentId) : void 0;
     return path.reverse(), path;
   }
   /**
@@ -892,7 +850,6 @@ export {
   migrateSessionEntries,
   parseSessionEntries,
   getLatestCompactionEntry,
-  validateSessionGraph,
   sessionEntryToContextMessages,
   buildContextEntries,
   buildSessionContext,

package/dist/node-runtime/{chunk-A2KQXUJD.js → chunk-7AFOFSDY.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   estimateTokens
-} from "./chunk-TQNSPERU.js";
+} from "./chunk-5SQDLSZJ.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>/;