@bli-cockpit/cli 0.2.263 → 0.2.265

package/dist/slim/slim-transcript.js

@@ -22,6 +22,7 @@
  * What each rule keeps and drops: claude-rules.ts and codex-rules.ts. The table for people:
  * docs/architecture/image-descriptions.md.
  */
+import { replaceImagesWithMarkers } from "@bli-cockpit/telemetry-core";
 import { newClaudeSlimState, slimClaudeRecord } from "./claude-rules.js";
 import { newCodexSlimState, slimCodexRecord } from "./codex-rules.js";
 import { LineEdits, SeenBlocks, isJsonObject } from "./slim-support.js";
@@ -103,17 +104,89 @@ function slimOneLine(line, applyRules, stats) {
     stats.linesModified += 1;
     return JSON.stringify(record) + (line.endsWith("\r") ? "\r" : "");
 }
-/** The slim form of a whole transcript's text, line for line. */
-export function slimTranscript(text, kind) {
+/**
+ * The slim form of a whole transcript's text, line for line, with the image swap folded into the
+ * same pass (BLI-23317). Output is byte-identical to `replaceImagesWithMarkers` followed by the old
+ * split/map/join: lines are found by `indexOf`, never `split`; a line no rule touched stays part of
+ * a slice of the input and is not copied on its own, so the only new allocation is the one joined
+ * result (and only when some line changed). An image sits inside one line (its characters exclude
+ * "\n"), so it is swapped inside that line before the rules read it, as the two-step order did.
+ */
+export function slimPass(text, kind, swap) {
     const slimmer = createSlimmer(kind);
-    const lines = text.split("\n");
-    const out = new Array(lines.length);
-    for (let index = 0; index < lines.length; index += 1)
-        out[index] = slimmer.slimLine(lines[index]);
+    const pieces = [];
+    let emitted = 0;
+    let nextImage = 0;
+    let replacedCount = 0;
+    let charsSaved = 0;
+    for (let position = 0;;) {
+        const newline = text.indexOf("\n", position);
+        const end = newline === -1 ? text.length : newline;
+        let line = text.slice(position, end);
+        let swapped = false;
+        if (swap) {
+            const local = [];
+            while (nextImage < swap.images.length && swap.images[nextImage].replaceStart < end) {
+                const image = swap.images[nextImage];
+                nextImage += 1;
+                if (image.replaceStart < position || image.replaceEnd > end)
+                    throw new Error("image_spans_lines");
+                local.push({
+                    ...image,
+                    replaceStart: image.replaceStart - position,
+                    replaceEnd: image.replaceEnd - position,
+                    base64Start: image.base64Start - position,
+                    base64End: image.base64End - position,
+                });
+            }
+            if (local.length > 0) {
+                const replaced = replaceImagesWithMarkers(line, local, swap.replace);
+                if (replaced.replacedCount > 0) {
+                    line = replaced.text;
+                    swapped = true;
+                    replacedCount += replaced.replacedCount;
+                    charsSaved += replaced.charsSaved;
+                }
+            }
+        }
+        const out = slimmer.slimLine(line);
+        if (swapped || out !== line) {
+            pieces.push(text.slice(emitted, position), out);
+            emitted = end;
+        }
+        if (newline === -1)
+            break;
+        position = newline + 1;
+    }
     const stats = slimmer.stats();
-    return { text: stats.linesModified === 0 ? text : out.join("\n"), stats };
+    if (pieces.length === 0)
+        return { text, stats, replacedCount, charsSaved, changed: false };
+    pieces.push(text.slice(emitted));
+    return { text: pieces.join(""), stats, replacedCount, charsSaved, changed: true };
+}
+/** The slim form of a whole transcript's text, line for line. */
+export function slimTranscript(text, kind) {
+    const slim = slimPass(text, kind);
+    return { text: slim.text, stats: slim.stats };
 }
 const TAG = "[slim-transcript]";
+export function logSlimmed(kind, sessionId, stats, startedAt) {
+    console.error(TAG + (stats.linesModified === 0 ? " nothing to strip" : " transcript slimmed"), JSON.stringify({
+        source: kind,
+        session_id: sessionId.slice(0, 80),
+        lines: stats.lines,
+        lines_modified: stats.linesModified,
+        lines_failed: stats.linesFailed,
+        bytes_before: stats.bytesBefore,
+        bytes_after: stats.bytesAfter,
+        chars_by_rule: stats.charsByRule,
+        lines_by_rule: stats.linesByRule,
+        elapsed_ms: Date.now() - startedAt,
+    }));
+}
+function logSlimFailed(kind, error, bytes) {
+    console.error(TAG + " failed, uploading the transcript as it was", JSON.stringify({ reason: "slim_failed", source: kind, error_name: error instanceof Error ? error.name : typeof error, bytes }));
+}
 /**
  * `slimTranscript` that can never fail a transcript: any exception returns the text it was given and
  * logs the reason. Metadata only: counts, sizes, rule names. Never a line, never a field value.
@@ -122,23 +195,27 @@ export function slimOrKeep(text, kind, label) {
     const startedAt = Date.now();
     try {
         const slim = slimTranscript(text, kind);
-        const stats = slim.stats;
-        console.error(TAG + (stats.linesModified === 0 ? " nothing to strip" : " transcript slimmed"), JSON.stringify({
-            source: kind,
-            session_id: label.sessionId.slice(0, 80),
-            lines: stats.lines,
-            lines_modified: stats.linesModified,
-            lines_failed: stats.linesFailed,
-            bytes_before: stats.bytesBefore,
-            bytes_after: stats.bytesAfter,
-            chars_by_rule: stats.charsByRule,
-            lines_by_rule: stats.linesByRule,
-            elapsed_ms: Date.now() - startedAt,
-        }));
-        return { text: slim.text, stats };
+        logSlimmed(kind, label.sessionId, slim.stats, startedAt);
+        return { text: slim.text, stats: slim.stats };
     }
     catch (error) {
-        console.error(TAG + " failed, uploading the transcript as it was", JSON.stringify({ reason: "slim_failed", source: kind, error_name: error instanceof Error ? error.name : typeof error, bytes: typeof text === "string" ? text.length : 0 }));
+        logSlimFailed(kind, error, typeof text === "string" ? text.length : 0);
         return { text, stats: null };
     }
+}
+/**
+ * `slimPass` that can never fail a transcript: a pass that throws (an image that would span lines,
+ * an exhausted string) logs the reason and returns null, and the caller takes the two-step path.
+ */
+export function slimPassOrNull(text, kind, label, swap) {
+    const startedAt = Date.now();
+    try {
+        const slim = slimPass(text, kind, swap);
+        logSlimmed(kind, label.sessionId, slim.stats, startedAt);
+        return slim;
+    }
+    catch (error) {
+        logSlimFailed(kind, error, text.length);
+        return null;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.263",
+  "version": "0.2.265",
   "private": false,
   "type": "module",
   "bin": {