@danypops/pi-jittor 0.2.0 → 0.3.0

package/extension/src/observability/context-view.ts

@@ -0,0 +1,264 @@
+import type { ContextDelta, ContextSegment } from "@danypops/jittor";
+import type { ExtensionCommandContext, Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { matchesKey, type TUI, truncateToWidth } from "@earendil-works/pi-tui";
+import {
+	type ContextBarTheme,
+	type ContextRow,
+	type ContextRowsTheme,
+	type ContextSegment as MalevichContextSegment,
+	renderContextRowLines,
+	renderContextUsageBar,
+} from "malevich-tui-components";
+import type { ContextBreakdown } from "./context-breakdown.ts";
+import { buildContextReport, buildContextRowsIterative } from "./context-report.ts";
+
+const VISIBLE_ROWS = 22;
+const MIN_TOKEN_FILTERS = [0, 100, 1_000, 10_000] as const;
+
+export type ContextRowScope = "all" | "active" | "historical";
+
+function rowTokens(row: ContextRow): number {
+	const match = row.isHeader ? row.text.match(/—\s+([\d,]+)\s+tok/) : row.text.match(/^\s*([\d,]+)\s+tok/);
+	return match ? Number(match[1]!.replaceAll(",", "")) : 0;
+}
+
+/** Filters the flattened pre-order tree while retaining every ancestor needed to understand a match. */
+export function filterContextRows(rows: readonly ContextRow[], query: string, scope: ContextRowScope, minimumTokens: number): ContextRow[] {
+	const terms = query.toLocaleLowerCase().trim().split(/\s+/).filter(Boolean);
+	const included = rows.map(() => false);
+	const parentByIndex: Array<number | null> = [];
+	const ancestors: number[] = [];
+	const historicalByDepth: boolean[] = [];
+	for (let index = 0; index < rows.length; index++) {
+		const row = rows[index]!;
+		while (ancestors.length > row.depth) ancestors.pop();
+		parentByIndex[index] = row.depth > 0 ? (ancestors[row.depth - 1] ?? null) : null;
+		const lower = row.text.toLocaleLowerCase();
+		const inheritedHistorical = row.depth > 0 ? (historicalByDepth[row.depth - 1] ?? false) : false;
+		const historical = inheritedHistorical || lower.includes("(inactive branch)") || lower.includes("(compacted)");
+		const scopeMatches = scope === "all" || (scope === "historical" ? historical : !historical);
+		const queryMatches = terms.every((term) => lower.includes(term));
+		included[index] = scopeMatches && queryMatches && rowTokens(row) >= minimumTokens;
+		ancestors[row.depth] = index;
+		ancestors.length = row.depth + 1;
+		historicalByDepth[row.depth] = historical;
+		historicalByDepth.length = row.depth + 1;
+	}
+	// Children follow parents in this pre-order list, so one reverse pass propagates every
+	// match to its ancestors in O(rows), even for a 50k-entry linear session tree.
+	for (let index = rows.length - 1; index >= 0; index--) {
+		if (!included[index]) continue;
+		const parent = parentByIndex[index];
+		if (parent !== null && parent !== undefined) included[parent] = true;
+	}
+	return rows.filter((_row, index) => included[index]);
+}
+
+/**
+ * A dynamically-contributed segment set (any string key from any extension, not a fixed enum)
+ * can't use a hardcoded per-key color map the way Papyrus's own ContextViewport did for its
+ * fixed seven segments -- this cycles a small categorical palette keyed by a stable hash of the
+ * segment key, so the same key always renders the same color within one process without needing
+ * every possible contributor's key to be known in advance.
+ */
+const PALETTE: ThemeColor[] = ["accent", "success", "syntaxFunction", "warning", "syntaxKeyword", "syntaxType", "muted"];
+
+function paletteColor(key: string): ThemeColor {
+	let hash = 0;
+	for (let index = 0; index < key.length; index += 1) hash = (hash * 31 + key.charCodeAt(index)) >>> 0;
+	return PALETTE[hash % PALETTE.length]!;
+}
+
+function formatTokenCount(tokens: number): string {
+	return tokens >= 1_000 ? `${(tokens / 1_000).toFixed(1)}k` : String(tokens);
+}
+
+function percentOf(part: number, whole: number): string {
+	return whole > 0 ? `${((part / whole) * 100).toFixed(1)}%` : "—";
+}
+
+function contextDeltaLines(delta: ContextDelta): string[] {
+	const lifecycle = new Map<string, number>();
+	for (const change of delta.changes) lifecycle.set(change.lifecycle, (lifecycle.get(change.lifecycle) ?? 0) + 1);
+	const lifecycleText = [...lifecycle.entries()].map(([name, count]) => `${name} ${count}`).join(" · ") || "none";
+	const growthText = delta.growthBySource
+		.filter((growth) => growth.deltaTokens !== 0)
+		.map((growth) => `${growth.source} ${growth.deltaTokens > 0 ? "+" : ""}${growth.deltaTokens.toLocaleString()} tok`)
+		.join(" · ");
+	const changed = delta.firstChangedSegment
+		? `first change: ${delta.firstChangedSegment.source} @ request ${delta.firstChangedSegment.requestPosition ?? "historical"}`
+		: delta.resetReason
+			? `comparison reset: ${delta.resetReason}`
+			: "request structure unchanged";
+	return [
+		`Stable prefix ${delta.stablePrefixTokens.toLocaleString()} tok · ${changed}`,
+		`Lifecycle ${lifecycleText} · growth ${growthText || "none"}${delta.truncated ? " · bounded snapshot (truncated)" : ""}`,
+		"Stable-prefix correlation is structural evidence, not provider cache proof.",
+	];
+}
+
+/** Folds each segment's confidence tier into its label so it survives Malevich's confidence-unaware row builder. */
+function withConfidenceLabel(segment: ContextSegment): MalevichContextSegment {
+	return {
+		key: segment.key,
+		label: `${segment.label} [${segment.confidence}]`,
+		estimatedTokens: segment.estimatedTokens,
+		items: segment.items,
+		unknown: segment.unknown,
+	};
+}
+
+class ContextViewport {
+	private offsetY = 0;
+	private readonly rows: ContextRow[];
+	private readonly segments: readonly MalevichContextSegment[];
+	private searchMode = false;
+	private query = "";
+	private scope: ContextRowScope = "all";
+	private minimumFilterIndex = 0;
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly theme: Theme,
+		private readonly breakdown: ContextBreakdown,
+		private readonly delta: ContextDelta | null,
+		private readonly close: () => void,
+	) {
+		// Heaviest-first: Malevich renders segments in the order given, so sorting by weight for a
+		// merged multi-producer view is this viewport's own policy, matching context-report.ts.
+		this.segments = [...breakdown.segments].sort((left, right) => right.estimatedTokens - left.estimatedTokens).map(withConfidenceLabel);
+		this.rows = buildContextRowsIterative(this.segments, breakdown.totalTokens ?? undefined);
+	}
+
+	invalidate(): void {}
+
+	private visibleRows(): ContextRow[] {
+		return filterContextRows(this.rows, this.query, this.scope, MIN_TOKEN_FILTERS[this.minimumFilterIndex]!);
+	}
+
+	private clampOffset(rows: readonly ContextRow[]): void {
+		this.offsetY = Math.min(this.offsetY, Math.max(0, rows.length - VISIBLE_ROWS));
+	}
+
+	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, "")];
+
+		const { totalTokens, effectiveBudget } = this.breakdown;
+		if (totalTokens !== null && effectiveBudget !== null) {
+			lines.push(
+				truncateToWidth(
+					`${formatTokenCount(totalTokens)} / ${formatTokenCount(effectiveBudget)} tokens (${percentOf(totalTokens, effectiveBudget)} of usable budget)`,
+					contentWidth,
+					"",
+				),
+			);
+		} else if (totalTokens !== null) {
+			lines.push(truncateToWidth(`${formatTokenCount(totalTokens)} tokens (model context window unknown)`, contentWidth, ""));
+		} else {
+			lines.push(theme.fg("dim", "No real usage reported yet — sizes below are estimates only"));
+		}
+
+		const colorFor = (key: string) => (s: string) => theme.fg(paletteColor(key), s);
+		const barTheme: ContextBarTheme = { colorFor, empty: (s) => theme.fg("dim", s) };
+		lines.push(renderContextUsageBar(barTheme, this.segments, contentWidth, effectiveBudget ?? undefined, 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(theme.fg("dim", "Exact-text items name the model tokenizer; ≈ uses char/4; provider request totals remain aggregate."));
+		if (this.delta) {
+			for (const line of contextDeltaLines(this.delta)) lines.push(truncateToWidth(theme.fg("muted", line), contentWidth, ""));
+		}
+		lines.push("");
+
+		const rowsTheme: ContextRowsTheme = { colorFor, header: (s) => theme.bold(s) };
+		const filteredRows = this.visibleRows();
+		this.clampOffset(filteredRows);
+		const visible = filteredRows.slice(this.offsetY, this.offsetY + VISIBLE_ROWS);
+		lines.push(...renderContextRowLines(visible, contentWidth, rowsTheme));
+		if (filteredRows.length === 0) lines.push(theme.fg("dim", "  (no matching context items)"));
+		else lines.push(theme.fg("muted", `  ${Math.min(this.offsetY + VISIBLE_ROWS, filteredRows.length)}/${filteredRows.length}`));
+
+		lines.push("");
+		const minimum = MIN_TOKEN_FILTERS[this.minimumFilterIndex]!;
+		const filterState = `scope: ${this.scope} · min: ${minimum === 0 ? "any" : `${formatTokenCount(minimum)} tok`}`;
+		lines.push(
+			truncateToWidth(
+				this.searchMode
+					? theme.fg("accent", `Search: ${this.query}▌ · ${filterState}`)
+					: theme.fg("muted", `${this.query ? `search: ${this.query} · ` : ""}${filterState}`),
+				contentWidth,
+				"",
+			),
+		);
+		lines.push(
+			theme.fg(
+				"dim",
+				this.searchMode
+					? "type to search · backspace edit · enter apply · esc clear"
+					: "/ search · f scope · m min tokens · g/G top/bottom · ↑↓ scroll · esc close",
+			),
+		);
+		lines.push(border);
+		return lines;
+	}
+
+	handleInput(data: string): void {
+		if (this.searchMode) {
+			if (matchesKey(data, "escape")) {
+				if (this.query.length > 0) this.query = "";
+				else this.searchMode = false;
+			} else if (matchesKey(data, "enter")) this.searchMode = false;
+			else if (matchesKey(data, "backspace")) this.query = this.query.slice(0, -1);
+			else if (/^[\x20-\x7e]+$/.test(data)) this.query += data;
+			else return;
+			this.offsetY = 0;
+			this.tui.requestRender();
+			return;
+		}
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			this.close();
+			return;
+		}
+		const rows = this.visibleRows();
+		if (data === "/") {
+			this.searchMode = true;
+			this.offsetY = 0;
+		} else if (data === "f") {
+			this.scope = this.scope === "all" ? "active" : this.scope === "active" ? "historical" : "all";
+			this.offsetY = 0;
+		} else if (data === "m") {
+			this.minimumFilterIndex = (this.minimumFilterIndex + 1) % MIN_TOKEN_FILTERS.length;
+			this.offsetY = 0;
+		} else if (data === "g") this.offsetY = 0;
+		else if (data === "G") this.offsetY = Math.max(0, rows.length - VISIBLE_ROWS);
+		else if (matchesKey(data, "up")) this.offsetY = Math.max(0, this.offsetY - 1);
+		else if (matchesKey(data, "down")) this.offsetY = Math.min(Math.max(0, rows.length - VISIBLE_ROWS), this.offsetY + 1);
+		else return;
+		this.tui.requestRender();
+	}
+}
+
+/** Interactive scrollable Context Hub view in TUI mode; the same plain-text report as /context's non-interactive path otherwise. */
+export async function showContextView(
+	ctx: ExtensionCommandContext,
+	breakdown: ContextBreakdown,
+	delta: ContextDelta | null = null,
+): Promise<void> {
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify([buildContextReport(breakdown), ...(delta ? ["", ...contextDeltaLines(delta)] : [])].join("\n"), "info");
+		return;
+	}
+	await ctx.ui.custom<void>((tui, theme, _keybindings, done) => new ContextViewport(tui, theme, breakdown, delta, done));
+}

package/extension/src/{footer.ts → observability/footer.ts}

@@ -1,13 +1,10 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { ProgressBar } from "malevich-tui-components";
 import {
 	FOOTER_BAR_MAX_WIDTH,
 	FOOTER_BAR_MIN_WIDTH,
+	FOOTER_COMPACTION_BLINK_HALF_PERIOD_MS,
 	FOOTER_CONTEXT_ACCENT_FRACTION,
 	FOOTER_CONTEXT_ERROR_FRACTION,
-	FOOTER_COMPACTION_BLINK_HALF_PERIOD_MS,
 	FOOTER_CONTEXT_WARNING_FRACTION,
 	FOOTER_WIDE_TERMINAL_WIDTH,
 	MILLISECONDS_PER_DAY,
@@ -15,6 +12,9 @@ import {
 	MILLISECONDS_PER_MINUTE,
 	TELEMETRY_STALE_AFTER_MS,
 } from "@danypops/jittor";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { ProgressBar } from "malevich-tui-components";
 
 type FooterColor = "accent" | "dim" | "warning" | "error";
 
@@ -48,19 +48,26 @@ interface FooterContext {
 }
 
 /** A bounded quota is explicitly remaining; unbounded values never receive a fabricated bar. */
-export type ProviderBudget = {
-	kind: "bounded";
-	label: string;
-	remainingFraction: number;
-	observedAt?: number;
-	resetsAt?: number;
-	resetText?: string;
-} | {
-	kind: "unbounded";
-	label: string;
-	valueText: string;
-	observedAt?: number;
-};
+export type ProviderBudget =
+	| {
+			kind: "bounded";
+			label: string;
+			remainingFraction: number;
+			observedAt?: number;
+			resetsAt?: number;
+			resetText?: string;
+	  }
+	| {
+			kind: "unbounded";
+			label: string;
+			valueText: string;
+			observedAt?: number;
+	  }
+	| {
+			kind: "unavailable";
+			label: string;
+			valueText: string;
+	  };
 
 export interface CompactionProgress {
 	startedAt: number;
@@ -92,17 +99,25 @@ function footerCwd(cwd: string, home: string | undefined): string {
 	const resolvedCwd = resolve(cwd);
 	const resolvedHome = resolve(home);
 	const relativeToHome = relative(resolvedHome, resolvedCwd);
-	const inside = relativeToHome === "" || (relativeToHome !== ".." && !relativeToHome.startsWith(`..${sep}`) && !isAbsolute(relativeToHome));
+	const inside =
+		relativeToHome === "" || (relativeToHome !== ".." && !relativeToHome.startsWith(`..${sep}`) && !isAbsolute(relativeToHome));
 	if (!inside) return cwd;
 	return relativeToHome === "" ? "~" : `~${sep}${relativeToHome}`;
 }
 
 function sanitize(value: string): string {
-	return value.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+	return value
+		.replace(/[\r\n\t]/g, " ")
+		.replace(/ +/g, " ")
+		.trim();
 }
 
 function usageTotals(context: FooterContext): UsageTotals {
-	let input = 0, output = 0, cacheRead = 0, cacheWrite = 0, cost = 0;
+	let input = 0,
+		output = 0,
+		cacheRead = 0,
+		cacheWrite = 0,
+		cost = 0;
 	for (const entry of context.sessionManager.getEntries()) {
 		if (entry.type !== "message" || entry.message?.role !== "assistant") continue;
 		const usage = entry.message.usage;
@@ -113,7 +128,7 @@ function usageTotals(context: FooterContext): UsageTotals {
 		cost += usage?.cost?.total ?? 0;
 	}
 	const prompt = input + cacheRead + cacheWrite;
-	return { input, output, cacheRead, cacheWrite, cost, ...(prompt > 0 ? { cacheHit: cacheRead / prompt * 100 } : {}) };
+	return { input, output, cacheRead, cacheWrite, cost, ...(prompt > 0 ? { cacheHit: (cacheRead / prompt) * 100 } : {}) };
 }
 
 function barWidth(width: number): number {
@@ -201,17 +216,25 @@ function resetLabel(resetsAt: number | undefined, now: number): string | undefin
  * the segment is omitted entirely rather than showing a placeholder that could never resolve.
  * `null` means not known yet but might resolve, which still earns the `?` placeholder.
  */
-function budgetSegment(budget: ProviderBudget | null | undefined, theme: FooterTheme, width: number, compact: boolean, now: number): string | undefined {
+function budgetSegment(
+	budget: ProviderBudget | null | undefined,
+	theme: FooterTheme,
+	width: number,
+	compact: boolean,
+	now: number,
+): string | undefined {
 	if (budget === undefined) return undefined;
 	const w = barWidth(width);
 	if (!budget) return `budget ${theme.fg("dim", progressBar(null, w))} ?`;
+	if (budget.kind === "unavailable") return `${budget.label} ${theme.fg("warning", budget.valueText)}`;
 	const stale = budget.observedAt !== undefined && now - budget.observedAt > TELEMETRY_STALE_AFTER_MS;
 	const staleText = stale ? ` ${theme.fg("warning", "stale")}` : "";
 	if (budget.kind === "unbounded") return `${budget.label} ${budget.valueText}${staleText}`;
+	if (budget.resetsAt !== undefined && budget.resetsAt <= now) return `${budget.label} ${theme.fg("warning", "reset pending")}`;
 	const remaining = Math.min(1, Math.max(0, budget.remainingFraction));
 	const bar = theme.fg(fillColor(1 - remaining), progressBar(remaining, w));
-	const value = `${(compact ? Math.round(remaining * 100) : (remaining * 100).toFixed(1))}% left`;
-	const reset = compact ? undefined : resetLabel(budget.resetsAt, now) ?? budget.resetText;
+	const value = `${compact ? Math.round(remaining * 100) : (remaining * 100).toFixed(1)}% left`;
+	const reset = compact ? undefined : (resetLabel(budget.resetsAt, now) ?? budget.resetText);
 	return `${budget.label} ${bar} ${value}${reset ? ` · ${reset}` : ""}${staleText}`;
 }
 
@@ -238,7 +261,12 @@ function repositorySegment(context: FooterContext, footerData: FooterData, theme
 	return theme.fg("dim", cwd);
 }
 
-function modelSegments(context: FooterContext, footerData: FooterData, theme: FooterTheme, thinkingLevel: string): { full: string; compact: string } {
+function modelSegments(
+	context: FooterContext,
+	footerData: FooterData,
+	theme: FooterTheme,
+	thinkingLevel: string,
+): { full: string; compact: string } {
 	const model = context.model;
 	const modelName = theme.bold(model?.id ?? "no-model");
 	const provider = model && footerData.getAvailableProviderCount() > 1 ? `(${model.provider}) ` : "";
@@ -312,7 +340,16 @@ export function installIntegratedFooter(ctx: ExtensionContext, state: Integrated
 		return {
 			invalidate() {},
 			render(width: number): string[] {
-				return renderFooterLines(ctx as unknown as FooterContext, footerData, theme, state.providerBudget, getThinkingLevel(), width, Date.now(), state.compaction);
+				return renderFooterLines(
+					ctx as unknown as FooterContext,
+					footerData,
+					theme,
+					state.providerBudget,
+					getThinkingLevel(),
+					width,
+					Date.now(),
+					state.compaction,
+				);
 			},
 			dispose() {
 				unsubscribe?.();

package/extension/src/{capabilities/local-run-telemetry.ts → observability/model-run.ts}

@@ -1,4 +1,4 @@
-import { classifyTaskFromTools, modelRunMetrics, type MetricObservation, type ModelRunObservation } from "@danypops/jittor";
+import { classifyTaskFromTools, type MetricObservation, type ModelRunObservation, modelRunMetrics } from "@danypops/jittor";
 
 export interface ActiveLocalModelRun {
 	runId: string;
@@ -59,18 +59,22 @@ export class LocalRunTelemetry {
 		this.active = undefined;
 		if (!active || typeof message !== "object" || message === null || Array.isArray(message)) return [];
 		const value = message as Record<string, unknown>;
-		if (value["role"] !== "assistant" || typeof value["provider"] !== "string" || typeof value["model"] !== "string") return [];
-		const usage = typeof value["usage"] === "object" && value["usage"] !== null ? value["usage"] as Record<string, unknown> : {};
-		const amount = (name: string): number => typeof usage[name] === "number" && Number.isFinite(usage[name]) ? usage[name] as number : 0;
-		const cost = typeof usage["cost"] === "object" && usage["cost"] !== null && typeof (usage["cost"] as Record<string, unknown>)["total"] === "number"
-			? (usage["cost"] as Record<string, number>)["total"] ?? 0 : 0;
-		const stopReason = ["stop", "length", "toolUse", "error", "aborted"].includes(String(value["stopReason"]))
-			? value["stopReason"] as ModelRunObservation["stopReason"] : "unknown";
+		if (value.role !== "assistant" || typeof value.provider !== "string" || typeof value.model !== "string") return [];
+		const usage = typeof value.usage === "object" && value.usage !== null ? (value.usage as Record<string, unknown>) : {};
+		const amount = (name: string): number =>
+			typeof usage[name] === "number" && Number.isFinite(usage[name]) ? (usage[name] as number) : 0;
+		const cost =
+			typeof usage.cost === "object" && usage.cost !== null && typeof (usage.cost as Record<string, unknown>).total === "number"
+				? ((usage.cost as Record<string, number>).total ?? 0)
+				: 0;
+		const stopReason = ["stop", "length", "toolUse", "error", "aborted"].includes(String(value.stopReason))
+			? (value.stopReason as ModelRunObservation["stopReason"])
+			: "unknown";
 		const completedAt = Math.max(Date.now(), active.firstTokenAt ?? active.startedAt, active.startedAt);
 		this.lastCompleted = {
 			runId: active.runId,
-			provider: value["provider"],
-			model: value["model"],
+			provider: value.provider,
+			model: value.model,
 			thinking: thinkingLevel,
 			...classifyTaskFromTools(active.toolNames),
 			startedAt: active.startedAt,