@oh-my-pi/snapcompact 18.14.1 → 18.15.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [18.15.0] - 2026-11-01
+
+### Added
+
+- Added `viewWithoutFrames`: what a reader without image input reads for an archive, its kept text in place of its frames ([#17510](https://github.com/can1357/oh-my-pi/pull/17510) by [@will-bogusz](https://github.com/will-bogusz))
+
 ## [18.13.3] - 2026-10-28
 
 ### Changed

package/dist/types/snapcompact.d.ts

@@ -676,6 +676,26 @@ export declare function textWithoutThinking(text: string): string;
  * file list.
  */
 export declare function viewWithoutThinking(summary: string, archive: Archive, details?: CompactionDetails): ArchiveView;
+/** Options for {@link viewWithoutFrames}. */
+export interface ViewWithoutFramesOptions {
+    /** `false` for a reader that excludes assistant reasoning ({@link readerIncludesThinking}). */
+    includeThinking?: boolean;
+    /** Most archive characters the reader takes; the middle past it is dropped, both ends kept. */
+    maxChars?: number;
+}
+/**
+ * What a reader without image input reads for a compaction whose summary is
+ * `summary` and archive `archive`: the archive's kept source
+ * ({@link Archive.text}) as plain text in place of its frames, and the summary
+ * re-rendered without the frame legend, its file list kept. With
+ * `includeThinking: false` the text and legend also leave out reasoning, as
+ * {@link viewWithoutThinking} does, without rendering frames this reader
+ * cannot see; past `maxChars` the middle of the text is dropped. An archive
+ * persisted without that source keeps its text edges and counts the imaged
+ * middle as dropped. An archive with no frames, no reasoning to drop and no
+ * text past `maxChars` is returned as is.
+ */
+export declare function viewWithoutFrames(summary: string, archive: Archive, options?: ViewWithoutFramesOptions): ArchiveView;
 /**
  * Run a snapcompact compaction over prepared messages. Fully local: serializes
  * the discarded history, appends it to the accumulated archive source text, and

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/snapcompact",
-	"version": "18.14.1",
+	"version": "18.15.0",
 	"description": "Bitmap-frame context compression for vision-capable LLMs",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -34,11 +34,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.14.1",
-		"@oh-my-pi/pi-catalog": "18.14.1",
-		"@oh-my-pi/pi-natives": "18.14.1",
-		"@oh-my-pi/pi-utils": "18.14.1",
-		"@oh-my-pi/pi-wire": "18.14.1"
+		"@oh-my-pi/pi-ai": "18.15.0",
+		"@oh-my-pi/pi-catalog": "18.15.0",
+		"@oh-my-pi/pi-natives": "18.15.0",
+		"@oh-my-pi/pi-utils": "18.15.0",
+		"@oh-my-pi/pi-wire": "18.15.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/prompts/snapcompact-summary.md

@@ -19,6 +19,7 @@ Reading HISTORY:
 {{/if}}{{#if truncatedChars}}- About {{truncatedChars}} characters of older middle history dropped to fit archive budget.
 {{/if}}- If an exact earlier detail matters and a section is unclear, re-derive from workspace (re-read files, re-run commands), rather than guess.
 
+{{!-- viewWithoutFrames (snapcompact.ts) reads this FILES section back out of a rendered summary: keep FILES_SECTION_HEAD and HISTORY_SECTION_HEAD in step with these headings. --}}
 {{#if files}}FILES
 ===================
 {{files}}

package/src/snapcompact.ts

@@ -2332,6 +2332,114 @@ export function viewWithoutThinking(summary: string, archive: Archive, details?:
 	};
 }
 
+const FILES_SECTION_HEAD = "FILES\n===================\n";
+const HISTORY_SECTION_HEAD = "HISTORY\n===================";
+
+/** The FILES section of a snapcompact summary as it was rendered, or `undefined` when it lists none. */
+function summaryFileSection(summary: string): string | undefined {
+	const start = summary.indexOf(FILES_SECTION_HEAD);
+	const end = summary.lastIndexOf(HISTORY_SECTION_HEAD);
+	if (start < 0 || end < start) return undefined;
+	const files = summary.slice(start + FILES_SECTION_HEAD.length, end).replace(TRAILING_LINE_BREAKS, "");
+	return files.length > 0 ? files : undefined;
+}
+
+/** Options for {@link viewWithoutFrames}. */
+export interface ViewWithoutFramesOptions {
+	/** `false` for a reader that excludes assistant reasoning ({@link readerIncludesThinking}). */
+	includeThinking?: boolean;
+	/** Most archive characters the reader takes; the middle past it is dropped, both ends kept. */
+	maxChars?: number;
+}
+
+/** `archive`'s text regions cut to `maxChars`, keeping both ends and counting the cut middle as dropped. */
+function keepEnds(archive: Archive, maxChars: number): Archive {
+	if (archive.totalChars <= maxChars) return archive;
+	let head = archive.textHead ?? "";
+	let tail = archive.textTail ?? "";
+	if (tail.length === 0) {
+		const headChars = Math.ceil(maxChars / 2);
+		tail = head.slice(head.length - (maxChars - headChars));
+		head = head.slice(0, headChars);
+	} else {
+		const headChars = Math.min(head.length, Math.max(Math.ceil(maxChars / 2), maxChars - tail.length));
+		const tailChars = Math.min(tail.length, maxChars - headChars);
+		head = head.slice(0, headChars);
+		tail = tail.slice(tail.length - tailChars);
+	}
+	const { textHead: _head, textTail: _tail, ...rest } = archive;
+	return {
+		...rest,
+		totalChars: head.length + tail.length,
+		truncatedChars: archive.truncatedChars + archive.totalChars - head.length - tail.length,
+		...(head ? { textHead: head } : {}),
+		...(tail ? { textTail: tail } : {}),
+	};
+}
+
+/**
+ * What a reader without image input reads for a compaction whose summary is
+ * `summary` and archive `archive`: the archive's kept source
+ * ({@link Archive.text}) as plain text in place of its frames, and the summary
+ * re-rendered without the frame legend, its file list kept. With
+ * `includeThinking: false` the text and legend also leave out reasoning, as
+ * {@link viewWithoutThinking} does, without rendering frames this reader
+ * cannot see; past `maxChars` the middle of the text is dropped. An archive
+ * persisted without that source keeps its text edges and counts the imaged
+ * middle as dropped. An archive with no frames, no reasoning to drop and no
+ * text past `maxChars` is returned as is.
+ */
+export function viewWithoutFrames(
+	summary: string,
+	archive: Archive,
+	options: ViewWithoutFramesOptions = {},
+): ArchiveView {
+	const dropThinking = options.includeThinking === false && summaryIncludesThinking(summary);
+	const fits = options.maxChars === undefined || archive.totalChars <= options.maxChars;
+	if (archive.frames.length === 0 && !dropThinking && fits) return { summary, archive };
+	const scrub = (text: string): string => (dropThinking ? textWithoutThinking(text) : text);
+	let textArchive: Archive;
+	if (archive.text) {
+		const text = scrub(archive.text);
+		textArchive = {
+			frames: [],
+			totalChars: text.length,
+			truncatedChars: archive.truncatedChars,
+			text,
+			textHead: text,
+		};
+	} else {
+		// Without the whole source the tail may open inside a section cut off in
+		// the dropped middle, whose scope is unknown; a reader without reasoning
+		// skips those lines (see sourceForReaderWithoutThinking).
+		const tail = archive.textTail ?? "";
+		const labelled = dropThinking ? tail.search(SECTION_START) : 0;
+		const keptTail = labelled < 0 ? "" : tail.slice(labelled);
+		const textHead = scrub(archive.textHead ?? "");
+		const textTail = scrub(keptTail);
+		const framedChars = archive.frames.reduce((sum, frame) => sum + frame.chars, 0);
+		textArchive = {
+			frames: [],
+			totalChars: textHead.length + textTail.length,
+			truncatedChars: archive.truncatedChars + framedChars + tail.length - keptTail.length,
+			...(textHead ? { textHead } : {}),
+			...(textTail ? { textTail } : {}),
+		};
+	}
+	if (options.maxChars !== undefined) textArchive = keepEnds(textArchive, Math.max(0, Math.floor(options.maxChars)));
+	const source = textArchive.text ?? textArchive.textHead ?? "";
+	return {
+		summary: prompt.render(snapcompactSummaryPrompt, {
+			frameCount: 0,
+			truncatedChars: textArchive.truncatedChars,
+			includedPreviousSummary: source.startsWith(PREVIOUS_SUMMARY_HEAD),
+			files: summaryFileSection(summary),
+			includeThinking: summaryIncludesThinking(summary) && !dropThinking,
+		}),
+		archive: textArchive,
+	};
+}
+
 /**
  * Run a snapcompact compaction over prepared messages. Fully local: serializes
  * the discarded history, appends it to the accumulated archive source text, and