@danypops/papyrus 0.34.2 → 0.35.0

package/extension/src/context-view.ts

@@ -1,222 +0,0 @@
-import type { ExtensionCommandContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
-import { matchesKey, truncateToWidth, type TUI } from "@earendil-works/pi-tui";
-import type { ContextBreakdown, ContextSegment, ContextSegmentItem } from "./context-budget.ts";
-
-const VISIBLE_ROWS = 24;
-
-const SEGMENT_COLORS: Record<ContextSegment["key"], ThemeColor> = {
-	rules: "accent",
-	tasks: "success",
-	skills: "mdLink",
-	basePrompt: "warning",
-	messageHistory: "syntaxFunction",
-	toolDefinitions: "syntaxKeyword",
-	other: "muted",
-};
-
-/**
- * One row in the unified scrollable view. Every segment that has any real (nonzero) content
- * is fully expanded inline -- there is no separate "select a segment, then drill in" step.
- * `key` drives this row's color; `isHeader` distinguishes a segment's own summary line from
- * its item rows underneath it.
- */
-export interface ContextRow {
-	key: ContextSegment["key"];
-	isHeader: boolean;
-	text: string;
-	/** Nesting depth for indentation -- 0 for a segment header or a top-level item, deeper for real tree children (message history branches, Task containment). */
-	depth: number;
-}
-
-function formatTokenCount(tokens: number): string {
-	return tokens >= 1000 ? `${(tokens / 1000).toFixed(1)}k` : String(tokens);
-}
-
-function percentOf(part: number, whole: number): string {
-	return whole > 0 ? `${((part / whole) * 100).toFixed(1)}%` : "—";
-}
-
-/**
- * Flattens every segment with real content into one linear row list, filtering out anything
- * that is genuinely zero rather than displaying a misleading "0 tok  0.0%" row -- a segment or
- * item with literally nothing in it carries no information and is pure noise in a scrollable
- * view meant to show where tokens actually go. A segment whose OWN total is zero but whose
- * items are also all zero is dropped entirely; a segment with a nonzero total is always kept
- * even if all its items individually round to zero (the total itself is real signal).
- */
-/** Recursively flattens one item and its real tree children (message history branches, Task containment) into indented rows, sorted biggest-first at each level -- a parent always immediately precedes its own children, never scrambled by a global sort. */
-function flattenItem(item: ContextSegmentItem, key: ContextSegment["key"], depth: number, rows: ContextRow[]): void {
-	rows.push({ key, isHeader: false, depth, text: `${item.estimatedTokens.toString().padStart(6)} tok  ${item.label}` });
-	const children = (item.children ?? []).filter((child) => child.estimatedTokens > 0).sort((a, b) => b.estimatedTokens - a.estimatedTokens);
-	for (const child of children) flattenItem(child, key, depth + 1, rows);
-}
-
-export function buildContextRows(breakdown: ContextBreakdown): ContextRow[] {
-	const rows: ContextRow[] = [];
-	const denominator = breakdown.totalTokens ?? breakdown.segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
-	for (const segment of breakdown.segments) {
-		const items = (segment.items ?? []).filter((item) => item.estimatedTokens > 0).sort((a, b) => b.estimatedTokens - a.estimatedTokens);
-		// A genuinely-unknown segment (basePrompt before the first observed turn) must stay
-		// visible even when its placeholder value is zero -- hiding it would misrepresent
-		// "not measured yet" as "measured and empty", the same honesty problem overshootTokens
-		// exists to prevent for the unaccounted bucket.
-		if (segment.estimatedTokens <= 0 && items.length === 0 && !segment.unknown) continue;
-		rows.push({
-			key: segment.key,
-			isHeader: true,
-			depth: 0,
-			text: `${segment.label} — ${segment.estimatedTokens} tok (${percentOf(segment.estimatedTokens, denominator)})`,
-		});
-		for (const item of items) flattenItem(item, segment.key, 1, rows);
-	}
-	return rows;
-}
-
-class ContextViewport {
-	private offsetY = 0;
-	private readonly rows: ContextRow[];
-
-	constructor(
-		private readonly tui: TUI,
-		private readonly theme: Theme,
-		private readonly breakdown: ContextBreakdown,
-		private readonly close: () => void,
-	) {
-		this.rows = buildContextRows(breakdown);
-	}
-
-	invalidate(): void {}
-
-	render(width: number): string[] {
-		const theme = this.theme;
-		const contentWidth = Math.max(1, width);
-		const border = theme.fg("borderMuted", "─".repeat(contentWidth));
-		const lines: string[] = [border, truncateToWidth(theme.fg("accent", theme.bold("Context")), contentWidth, "")];
-
-		if (this.breakdown.totalTokens !== null && this.breakdown.effectiveBudget !== null) {
-			const percent = percentOf(this.breakdown.totalTokens, this.breakdown.effectiveBudget);
-			lines.push(truncateToWidth(
-				`${formatTokenCount(this.breakdown.totalTokens)} / ${formatTokenCount(this.breakdown.effectiveBudget)} tokens (${percent} of usable budget)`,
-				contentWidth,
-				"",
-			));
-		} else if (this.breakdown.totalTokens !== null) {
-			lines.push(truncateToWidth(`${formatTokenCount(this.breakdown.totalTokens)} tokens (model context window unknown)`, contentWidth, ""));
-		} else {
-			lines.push(theme.fg("dim", "No real usage reported yet — sizes below are Papyrus's own estimates only"));
-		}
-		lines.push(renderContextBar(theme, this.breakdown.segments, contentWidth, this.breakdown.effectiveBudget ?? undefined, this.breakdown.totalTokens ?? undefined));
-		if (this.breakdown.overshootTokens > 0) {
-			lines.push(truncateToWidth(theme.fg("warning", `Estimates exceed real total by ~${this.breakdown.overshootTokens} tok — sizes below are approximate, not exact`), contentWidth, ""));
-		}
-		lines.push("");
-
-		this.visibleWindow().forEach(({ row, index }) => {
-			const gutter = theme.fg(SEGMENT_COLORS[row.key], "▌");
-			const indent = "  ".repeat(row.depth);
-			const text = row.isHeader ? theme.bold(row.text) : `${indent}${row.text}`;
-			lines.push(truncateToWidth(`${gutter} ${text}`, contentWidth, ""));
-			void index;
-		});
-		if (this.rows.length === 0) lines.push(theme.fg("dim", "  (nothing observed yet)"));
-		else lines.push(theme.fg("muted", `  ${Math.min(this.offsetY + VISIBLE_ROWS, this.rows.length)}/${this.rows.length}`));
-
-		lines.push("");
-		lines.push(theme.fg("dim", "↑↓ scroll · esc close"));
-		lines.push(border);
-		return lines;
-	}
-
-	private visibleWindow(): Array<{ row: ContextRow; index: number }> {
-		const end = Math.min(this.offsetY + VISIBLE_ROWS, this.rows.length);
-		const result: Array<{ row: ContextRow; index: number }> = [];
-		for (let index = this.offsetY; index < end; index++) result.push({ row: this.rows[index]!, index });
-		return result;
-	}
-
-	handleInput(data: string): void {
-		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.close(); return; }
-		if (matchesKey(data, "up")) this.offsetY = Math.max(0, this.offsetY - 1);
-		else if (matchesKey(data, "down")) this.offsetY = Math.min(Math.max(0, this.rows.length - VISIBLE_ROWS), this.offsetY + 1);
-		else return;
-		this.tui.requestRender();
-	}
-}
-
-/**
- * Distributes `totalCells` proportionally across `weights` (parallel arrays), guaranteeing
- * every genuinely-positive weight gets at least one cell when there is room for all of them
- * to (totalCells >= weights.length) -- a real, nonzero segment must stay visible even when
- * dwarfed by a much larger one, not round away to nothing. The largest resulting cell count
- * absorbs whatever rounding leaves over or short, so the sum always equals totalCells exactly.
- */
-function distributeCells(weights: readonly number[], totalCells: number): number[] {
-	const sum = weights.reduce((a, b) => a + b, 0);
-	if (sum <= 0 || totalCells <= 0 || weights.length === 0) return weights.map(() => 0);
-	let cells = weights.map((weight) => Math.round((weight / sum) * totalCells));
-	if (totalCells >= weights.length) cells = cells.map((count) => (count === 0 ? 1 : count));
-	const diff = totalCells - cells.reduce((a, b) => a + b, 0);
-	if (diff !== 0) {
-		const maxIndex = cells.indexOf(Math.max(...cells));
-		cells[maxIndex] = (cells[maxIndex] ?? 0) + diff;
-	}
-	return cells;
-}
-
-/**
- * Renders the context window as one horizontal stacked bar: one colored run of block
- * characters per USED segment, followed by a gray/dim run of "░" cells for the remaining,
- * genuinely EMPTY context window -- this is the "total used vs. unused" graph. A zero-token
- * breakdown (nothing observed yet) renders an entirely gray/dim track rather than a
- * divide-by-zero, since 0 used really does mean the whole window is empty right now.
- *
- * `capacity` is the real denominator (Papyrus's own effectiveBudget, matching the percentage
- * already shown in the text line above this bar). `usedTokens` is the real, ground-truth used
- * amount (breakdown.totalTokens) the used-vs-unused split is measured against -- NOT the sum of
- * `segments`' own estimates. That distinction is load-bearing: a live-reported bug showed a
- * fully solid bar with zero gray even though the header read "55.9% of usable budget", because
- * the old code compared `capacity` against the SUM of estimated segments, which independently
- * overshot both the real total and the capacity itself (a session whose message-history
- * estimate alone summed to over 1.5M tokens against a real ~550k total) -- the exact estimate-
- * overshoot dishonesty `overshootTokens` exists to surface elsewhere was silently defeating the
- * bar's own gray/used split. `usedTokens` defaults to the segment sum only when omitted, for
- * callers with no real total available. Segments still split the USED portion proportionally to
- * their own estimated share of each other (via distributeCells, which also guarantees a tiny
- * nonzero segment stays visible rather than rounding to nothing next to a much larger one).
- */
-export function renderContextBar(theme: Theme, segments: ReadonlyArray<ContextSegment>, width: number, capacity?: number, usedTokens?: number): string {
-	const estimatedSum = segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
-	if (estimatedSum <= 0 || width <= 0) return theme.fg("dim", "░".repeat(Math.max(0, width)));
-	const realUsed = usedTokens ?? estimatedSum;
-	const usedWidth = capacity !== undefined ? Math.max(0, Math.min(width, Math.round((realUsed / capacity) * width))) : width;
-
-	const nonZero = segments.filter((segment) => segment.estimatedTokens > 0);
-	const cellCounts = distributeCells(nonZero.map((segment) => segment.estimatedTokens), usedWidth);
-	let output = "";
-	nonZero.forEach((segment, index) => {
-		const cells = cellCounts[index] ?? 0;
-		if (cells > 0) output += theme.fg(SEGMENT_COLORS[segment.key], "█".repeat(cells));
-	});
-	const emptyWidth = width - usedWidth;
-	if (emptyWidth > 0) output += theme.fg("dim", "░".repeat(emptyWidth));
-	return output;
-}
-
-/** Non-interactive fallback (print mode, RPC, etc.): the same unified row list, as plain text lines. */
-function fallbackReport(breakdown: ContextBreakdown): string {
-	const totalLine = breakdown.totalTokens !== null
-		? `Real usage: ${breakdown.totalTokens} tokens${breakdown.effectiveBudget !== null ? ` / ${breakdown.effectiveBudget} usable budget (${percentOf(breakdown.totalTokens, breakdown.effectiveBudget)})` : ""}`
-		: "Real usage: not yet reported";
-	const overshootLine = breakdown.overshootTokens > 0 ? [`Estimates exceed real total by ~${breakdown.overshootTokens} tok -- sizes below are approximate, not exact`] : [];
-	const rows = buildContextRows(breakdown);
-	const rowLines = rows.length > 0 ? rows.map((row) => (row.isHeader ? row.text : `${"  ".repeat(row.depth)}${row.text}`)) : ["(nothing observed yet)"];
-	return [totalLine, ...overshootLine, "", ...rowLines].join("\n");
-}
-
-export async function showContextView(ctx: ExtensionCommandContext, breakdown: ContextBreakdown): Promise<void> {
-	if (ctx.mode !== "tui") {
-		ctx.ui.notify(fallbackReport(breakdown), "info");
-		return;
-	}
-	await ctx.ui.custom<void>((tui, theme, _keybindings, done) => new ContextViewport(tui, theme, breakdown, done));
-}

package/extension/src/discuss-ask-layout.ts

@@ -1,193 +0,0 @@
-/**
- * discuss-ask-layout.ts — row layout for the searchable single-select list used by Discuss's
- * live:true ask UI (discuss-ask-view.ts). Wraps long option titles/descriptions to a target
- * width and returns flat annotated rows, windowed around the current selection when the full
- * list would overflow the available rows.
- *
- * Adapted from pi-ask-user's single-select-layout.ts (MIT, Copyright (c) 2026 Enzo Lucchesi --
- * see THIRD_PARTY_LICENSES.md) so Discuss owns this UI directly instead of depending on that
- * package at runtime.
- */
-
-export interface AskOption {
-	title: string;
-	description?: string;
-}
-
-export interface AnnotatedRow {
-	line: string;
-	selected: boolean;
-}
-
-export interface RenderSingleSelectRowsParams {
-	options: AskOption[];
-	selectedIndex: number;
-	width: number;
-	allowFreeform: boolean;
-	allowComment?: boolean;
-	commentEnabled?: boolean;
-	maxRows?: number;
-	hideDescriptions?: boolean;
-}
-
-function wrapText(text: string, width: number): string[] {
-	const normalized = text.replace(/\s+/g, " ").trim();
-	if (!normalized) return [""];
-	if (width <= 1) return normalized.split("");
-
-	const words = normalized.split(" ");
-	const lines: string[] = [];
-	let current = "";
-
-	for (const word of words) {
-		if (!current) {
-			if (word.length <= width) {
-				current = word;
-			} else {
-				for (let i = 0; i < word.length; i += width) {
-					lines.push(word.slice(i, i + width));
-				}
-			}
-			continue;
-		}
-
-		const candidate = `${current} ${word}`;
-		if (candidate.length <= width) {
-			current = candidate;
-			continue;
-		}
-
-		lines.push(current);
-		if (word.length <= width) {
-			current = word;
-		} else {
-			current = "";
-			for (let i = 0; i < word.length; i += width) {
-				const chunk = word.slice(i, i + width);
-				if (chunk.length === width || i + width < word.length) lines.push(chunk);
-				else current = chunk;
-			}
-		}
-	}
-
-	if (current) lines.push(current);
-	return lines;
-}
-
-function padLine(prefix: string, content: string): string {
-	return `${prefix}${content}`.trimEnd();
-}
-
-interface ItemBlock {
-	itemIndex: number;
-	lines: string[];
-}
-
-type ListItem =
-	| { type: "option"; option: AskOption }
-	| { type: "comment-toggle"; option: AskOption }
-	| { type: "freeform"; option: AskOption };
-
-function buildItemBlocks(
-	options: AskOption[],
-	width: number,
-	allowFreeform: boolean,
-	allowComment: boolean,
-	commentEnabled: boolean,
-	selectedIndex: number,
-	hideDescriptions = false,
-): ItemBlock[] {
-	const normalizedWidth = Math.max(12, width);
-	const freeformLabel = "Type something. — Enter a custom response";
-	const commentToggleLabel = `${commentEnabled ? "[✓]" : "[ ]"} Add extra context after selection`;
-	const allItems: ListItem[] = options.map((option) => ({ type: "option", option }));
-	if (allowComment) allItems.push({ type: "comment-toggle", option: { title: commentToggleLabel } });
-	if (allowFreeform) allItems.push({ type: "freeform", option: { title: freeformLabel } });
-
-	return allItems.map((item, itemIndex) => {
-		const pointer = itemIndex === selectedIndex ? "→" : " ";
-		const lines: string[] = [];
-
-		if (item.type === "comment-toggle" || item.type === "freeform") {
-			const prefix = `${pointer}   `;
-			const wrapped = wrapText(item.option.title, Math.max(8, normalizedWidth - prefix.length));
-			wrapped.forEach((line, lineIndex) => {
-				lines.push(padLine(lineIndex === 0 ? prefix : " ".repeat(prefix.length), line));
-			});
-			return { itemIndex, lines };
-		}
-
-		const numberPrefix = `${pointer} ${itemIndex + 1}. `;
-		const continuationPrefix = " ".repeat(numberPrefix.length);
-		const titleLines = wrapText(item.option.title, Math.max(8, normalizedWidth - numberPrefix.length));
-		titleLines.forEach((line, lineIndex) => {
-			lines.push(padLine(lineIndex === 0 ? numberPrefix : continuationPrefix, line));
-		});
-
-		if (item.option.description && !hideDescriptions) {
-			const descriptionPrefix = "      ";
-			const descriptionLines = wrapText(item.option.description, Math.max(8, normalizedWidth - descriptionPrefix.length));
-			descriptionLines.forEach((line) => lines.push(padLine(descriptionPrefix, line)));
-		}
-
-		return { itemIndex, lines };
-	});
-}
-
-function flatten(blocks: ItemBlock[], selectedIndex: number): AnnotatedRow[] {
-	return blocks.flatMap((block) => block.lines.map((line) => ({ line, selected: block.itemIndex === selectedIndex })));
-}
-
-export function renderSingleSelectRows({
-	options,
-	selectedIndex,
-	width,
-	allowFreeform,
-	allowComment = false,
-	commentEnabled = false,
-	maxRows,
-	hideDescriptions,
-}: RenderSingleSelectRowsParams): AnnotatedRow[] {
-	const itemCount = options.length + (allowComment ? 1 : 0) + (allowFreeform ? 1 : 0);
-	const blocks = buildItemBlocks(options, width, allowFreeform, allowComment, commentEnabled, selectedIndex, hideDescriptions);
-	const allRows = flatten(blocks, selectedIndex);
-
-	if (!Number.isFinite(maxRows) || !maxRows || maxRows <= 0 || allRows.length <= maxRows) return allRows;
-
-	const safeMaxRows = Math.max(1, Math.floor(maxRows));
-	const selectedBlock = blocks[selectedIndex] ?? blocks[0];
-	if (!selectedBlock) return [];
-
-	const indicator = `  (${selectedIndex + 1}/${itemCount})`;
-	const availableRows = safeMaxRows > 1 ? safeMaxRows - 1 : 1;
-
-	if (selectedBlock.lines.length >= availableRows) {
-		const visible = selectedBlock.lines.slice(0, availableRows).map((line) => ({ line, selected: true }));
-		if (safeMaxRows > 1) visible.push({ line: indicator, selected: false });
-		return visible.slice(0, safeMaxRows);
-	}
-
-	let start = selectedIndex;
-	let end = selectedIndex + 1;
-	let usedRows = selectedBlock.lines.length;
-
-	while (true) {
-		const nextCanFit = end < blocks.length && usedRows + blocks[end]!.lines.length <= availableRows;
-		if (nextCanFit) {
-			usedRows += blocks[end]!.lines.length;
-			end += 1;
-			continue;
-		}
-		const prevCanFit = start > 0 && usedRows + blocks[start - 1]!.lines.length <= availableRows;
-		if (prevCanFit) {
-			start -= 1;
-			usedRows += blocks[start]!.lines.length;
-			continue;
-		}
-		break;
-	}
-
-	const visible = flatten(blocks.slice(start, end), selectedIndex);
-	visible.push({ line: indicator, selected: false });
-	return visible.slice(0, safeMaxRows);
-}