praxis-agent 0.34.0 → 0.35.0

package/dist/cli/tui/transcript-presentation.js

@@ -0,0 +1,169 @@
+function pairResults(items) {
+    const toolResults = new Map();
+    const toolResultIndexes = new Map();
+    const toolCallIndexesByResult = new Map();
+    const pairedToolResultIndexes = new Set();
+    const shellResults = new Map();
+    const shellResultIndexes = new Map();
+    const pairedShellResultIndexes = new Set();
+    const pendingTools = new Map();
+    const pendingShells = new Map();
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (!item)
+            continue;
+        if (item.kind === 'tool') {
+            const pending = pendingTools.get(item.call.id) ?? { indexes: [], next: 0 };
+            pending.indexes.push(index);
+            pendingTools.set(item.call.id, pending);
+        }
+        else if (item.kind === 'tool-result') {
+            const pending = pendingTools.get(item.callId);
+            const callIndex = pending?.indexes[pending.next];
+            if (pending && callIndex !== undefined) {
+                pending.next += 1;
+                toolResults.set(callIndex, item);
+                toolResultIndexes.set(callIndex, index);
+                toolCallIndexesByResult.set(index, callIndex);
+                pairedToolResultIndexes.add(index);
+            }
+            if (pending && pending.next === pending.indexes.length) {
+                pendingTools.delete(item.callId);
+            }
+        }
+        else if (item.kind === 'shell') {
+            const pending = pendingShells.get(item.callId) ?? { indexes: [], next: 0 };
+            pending.indexes.push(index);
+            pendingShells.set(item.callId, pending);
+        }
+        else if (item.kind === 'shell-result') {
+            const pending = pendingShells.get(item.callId);
+            const callIndex = pending?.indexes[pending.next];
+            if (pending && callIndex !== undefined) {
+                pending.next += 1;
+                shellResults.set(callIndex, item);
+                shellResultIndexes.set(callIndex, index);
+                pairedShellResultIndexes.add(index);
+            }
+            if (pending && pending.next === pending.indexes.length) {
+                pendingShells.delete(item.callId);
+            }
+        }
+    }
+    return {
+        toolResults,
+        toolResultIndexes,
+        toolCallIndexesByResult,
+        pairedToolResultIndexes,
+        shellResults,
+        shellResultIndexes,
+        pairedShellResultIndexes,
+    };
+}
+function readSummaryCount(items, start, pairing, cache) {
+    if (cache.has(start))
+        return cache.get(start);
+    const reads = [];
+    const readIndexes = new Set();
+    let cursor = start;
+    const failed = () => {
+        for (const readIndex of reads)
+            cache.set(readIndex, undefined);
+        return undefined;
+    };
+    while (cursor < items.length) {
+        const item = items[cursor];
+        if (item?.kind === 'tool' && item.call.name === 'Read') {
+            reads.push(cursor);
+            readIndexes.add(cursor);
+            cursor += 1;
+            continue;
+        }
+        if (item?.kind === 'tool-result' &&
+            pairing.toolCallIndexesByResult.has(cursor) &&
+            readIndexes.has(pairing.toolCallIndexesByResult.get(cursor) ?? -1)) {
+            if (item.isError)
+                return failed();
+            cursor += 1;
+            continue;
+        }
+        break;
+    }
+    if (reads.length === 0 ||
+        reads.some((index) => {
+            const resultIndex = pairing.toolResultIndexes.get(index);
+            return resultIndex === undefined || resultIndex >= cursor;
+        })) {
+        return failed();
+    }
+    const summary = { count: reads.length, end: cursor };
+    cache.set(start, summary);
+    return summary;
+}
+export function projectTranscriptPresentation(items, mode) {
+    const pairing = pairResults(items);
+    const entries = [];
+    const readSummaryCache = new Map();
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (!item)
+            continue;
+        if (mode === 'normal' &&
+            item.kind === 'tool' &&
+            item.call.name === 'Read') {
+            const summary = readSummaryCount(items, index, pairing, readSummaryCache);
+            if (summary) {
+                entries.push({
+                    kind: 'read-summary',
+                    key: `read-summary-${index}`,
+                    count: summary.count,
+                });
+                index = summary.end - 1;
+                continue;
+            }
+        }
+        if (item.kind === 'tool') {
+            const result = pairing.toolResults.get(index);
+            entries.push({
+                kind: 'tool',
+                key: `tool-${index}-${item.call.id}`,
+                item,
+                ...(result ? { result } : {}),
+            });
+            continue;
+        }
+        if (item.kind === 'tool-result') {
+            if (pairing.pairedToolResultIndexes.has(index))
+                continue;
+            entries.push({
+                kind: 'orphan-tool-result',
+                key: `tool-result-${index}`,
+                item,
+            });
+            continue;
+        }
+        if (item.kind === 'shell') {
+            const result = pairing.shellResults.get(index);
+            entries.push({
+                kind: 'shell',
+                key: `shell-${index}-${item.callId}`,
+                item,
+                ...(result ? { result } : {}),
+            });
+            continue;
+        }
+        if (item.kind === 'shell-result') {
+            if (pairing.pairedShellResultIndexes.has(index))
+                continue;
+            entries.push({
+                kind: 'orphan-shell-result',
+                key: `shell-result-${index}`,
+                item,
+            });
+            continue;
+        }
+        entries.push({ kind: 'item', key: `item-${index}`, item });
+    }
+    return entries;
+}
+//# sourceMappingURL=transcript-presentation.js.map

package/dist/cli/tui/transcript-viewport.d.ts

@@ -1,37 +1,8 @@
-import type { TranscriptItem } from './claude-style.js';
-/**
- * Rows reserved outside the shrinkable fullscreen transcript region: the top
- * identity chrome, the composer separator/prompt/footer, and the status line,
- * plus a small headroom so the active streaming tail stays visible below the
- * projected history suffix. Fullscreen computes the transcript budget as
- * `rows - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS`.
- */
+import type { TranscriptPresentationEntry, TranscriptPresentationMode } from './transcript-presentation.js';
 export declare const FULLSCREEN_TRANSCRIPT_RESERVED_ROWS = 12;
-/**
- * Compact marker prepended to the projected tail of an oversized newest item so
- * the truncation is visually explicit while the newest lines remain visible.
- */
 export declare const TRANSCRIPT_TRUNCATION_MARKER = "\u2026";
-/**
- * Deterministic estimate of the terminal rows one transcript item occupies in
- * the TUI presentation. It is intentionally conservative (leans toward
- * overestimation) so the suffix projector keeps the newest content visible
- * rather than dropping items that would actually render.
- */
-export declare function estimateTranscriptLines(item: TranscriptItem, width: number): number;
-export declare function transcriptLineCount(items: readonly TranscriptItem[], width: number): number;
-/**
- * Pure, deterministic suffix projector for the fullscreen transcript region.
- *
- * Given transcript items, a terminal row budget, and the usable width, it
- * returns the longest suffix of items whose conservative line estimate fits
- * the budget. The newest user/assistant content is always retained; if even
- * the newest item exceeds the budget, that item is projected as a bounded tail
- * clone rather than rendering an empty transcript (or clipping the tail below
- * the viewport). Ordering and item object identity are preserved for items
- * that fit and the input is never mutated.
- */
-export declare function projectTranscriptTail(items: readonly TranscriptItem[], budget: number, width: number): readonly TranscriptItem[];
-/** Projects a fixed-size transcript window, measured upward from the newest row. */
-export declare function projectTranscriptWindow(items: readonly TranscriptItem[], budget: number, width: number, scrollOffset: number): readonly TranscriptItem[];
+export declare function estimateTranscriptEntryLines(entry: TranscriptPresentationEntry, width: number, mode: TranscriptPresentationMode): number;
+export declare function transcriptPresentationLineCount(entries: readonly TranscriptPresentationEntry[], width: number, mode: TranscriptPresentationMode): number;
+export declare function projectTranscriptPresentationTail(entries: readonly TranscriptPresentationEntry[], budget: number, width: number, mode: TranscriptPresentationMode): readonly TranscriptPresentationEntry[];
+export declare function projectTranscriptPresentationWindow(entries: readonly TranscriptPresentationEntry[], budget: number, width: number, scrollOffset: number, mode: TranscriptPresentationMode): readonly TranscriptPresentationEntry[];
 //# sourceMappingURL=transcript-viewport.d.ts.map