pi-ui-extend 0.1.47 → 0.1.49

package/dist/app/rendering/conversation-tool-renderer.js

@@ -31,7 +31,6 @@ export function renderConversationToolEntry(entry, width, options) {
         id: entry.id,
         toolName,
         headerArgs: display.headerArgs,
-        headerArgsSegments: display.headerArgsSegments,
         bodyLineStyles: display.bodyLineStyles,
         bodyStyle: display.bodyStyle,
         preserveAnsi: display.preserveAnsi,

package/dist/app/rendering/tool-block-renderer.d.ts

@@ -2,13 +2,12 @@ import { type ResolvedToolRule } from "../../config.js";
 import type { ToolBodySyntaxHighlights } from "../../syntax-highlight.js";
 import type { Theme } from "../../theme.js";
 import type { RenderedLine } from "../types.js";
-import type { ToolBodyLineStyle, ToolHeaderSegment } from "../../tool-renderers/types.js";
+import type { ToolBodyLineStyle } from "../../tool-renderers/types.js";
 export type ToolBlockEntry = {
     id: string;
     toolName: string;
     headerLabel?: string | undefined;
     headerArgs?: string | undefined;
-    headerArgsSegments?: readonly ToolHeaderSegment[] | undefined;
     bodyLineStyles?: readonly ToolBodyLineStyle[] | undefined;
     bodyStyle?: "diff" | undefined;
     preserveAnsi?: boolean | undefined;

package/dist/app/rendering/tool-block-renderer.js

@@ -19,7 +19,7 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     const expanded = entry.expanded;
     const stateIcon = toolStatusIcon(entry);
     const toolColor = options.headerColorOverride ?? resolveColor(rule.color, colors);
-    const toolOutputColor = colors.statusForeground;
+    const toolOutputColor = toolColor;
     const headerLabel = (entry.headerLabel ?? entry.toolName).toLowerCase();
     const bg = options.backgroundOverride;
     const applyBackground = bg ? (lines) => { for (const line of lines)
@@ -31,7 +31,6 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     const target = { kind: "tool", id: entry.id };
     const showGutter = options.showGutter ?? true;
     const header = clippedHeaderArgs ? `${headerPrefix} ${clippedHeaderArgs}` : headerPrefix;
-    const headerArgsStart = clippedHeaderArgs ? headerPrefix.length + 1 : header.length;
     const headerLine = {
         text: header,
         target,
@@ -40,7 +39,6 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
         segments: [
             { start: 0, end: stateIcon.length, foreground: toolStatusIconColor(entry, colors), bold: true },
             { start: stateIcon.length, end: headerPrefix.length, bold: true },
-            ...headerArgsStyledSegments(headerArgsStart, clippedHeaderArgs.length, entry.headerArgsSegments, colors),
         ],
     };
     const headerLines = [headerLine];
@@ -484,38 +482,3 @@ function diffLineStyle(line, colors) {
 function formatToolHeaderArgs(argsText) {
     return sanitizeText(argsText ?? "").replace(/\n+/g, " ").trim();
 }
-function headerArgsStyledSegments(headerArgsStart, clippedLength, customSegments, colors) {
-    if (clippedLength <= 0)
-        return [];
-    if (!customSegments || customSegments.length === 0)
-        return [{ start: headerArgsStart, end: headerArgsStart + clippedLength, foreground: colors.muted }];
-    const segments = [];
-    let offset = 0;
-    const clippedCustomSegments = customSegments
-        .map((segment) => clippedHeaderSegment(segment, clippedLength))
-        .filter((segment) => segment !== undefined)
-        .sort((left, right) => left.start - right.start || left.end - right.end);
-    for (const segment of clippedCustomSegments) {
-        const start = Math.max(offset, segment.start);
-        if (start >= segment.end)
-            continue;
-        if (start > offset)
-            segments.push({ start: headerArgsStart + offset, end: headerArgsStart + start, foreground: colors.muted });
-        segments.push({
-            ...segment,
-            start: headerArgsStart + start,
-            end: headerArgsStart + segment.end,
-        });
-        offset = segment.end;
-    }
-    if (offset < clippedLength)
-        segments.push({ start: headerArgsStart + offset, end: headerArgsStart + clippedLength, foreground: colors.muted });
-    return segments;
-}
-function clippedHeaderSegment(segment, clippedLength) {
-    const start = Math.max(0, Math.min(clippedLength, segment.start));
-    const end = Math.max(start, Math.min(clippedLength, segment.end));
-    if (end <= start)
-        return undefined;
-    return { ...segment, start, end };
-}

package/dist/tool-renderers/compress.js

@@ -1,4 +1,4 @@
-import { compactProgressBarSegments, formatCompactProgressBar } from "../context-progress-bar.js";
+import { formatCompactProgressBar } from "../context-progress-bar.js";
 import { parseArgsText, stringArg } from "./utils.js";
 export const renderCompressTool = (input) => {
     const topic = stringArg(input, ["topic"]);
@@ -6,7 +6,6 @@ export const renderCompressTool = (input) => {
     const header = joinHeaderParts(topic ? { text: topic } : undefined, summary) ?? { text: "" };
     return {
         ...(header.text ? { headerArgs: header.text } : {}),
-        ...((header.segments?.length ?? 0) > 0 ? { headerArgsSegments: header.segments } : {}),
         collapsedBody: "",
         expandedText: fullCompressResponse(input.output, input.status),
     };
@@ -20,14 +19,14 @@ function formatCompressSummary(input) {
     const parsed = parseArgsText(output);
     if (!isRecord(parsed))
         return { text: oneLine(output) };
-    return formatCompressSuccess(parsed, input);
+    return formatCompressSuccess(parsed);
 }
 function fullCompressResponse(output, status) {
     if (output.trim())
         return output.trimEnd();
     return status === "running" ? "running…" : "(empty)";
 }
-function formatCompressSuccess(result, input) {
+function formatCompressSuccess(result) {
     const tokensSaved = numberValue(result.tokensSaved);
     const contextPercent = numberValue(result.contextPercent);
     const contextTokens = numberValue(result.contextTokens);
@@ -43,7 +42,7 @@ function formatCompressSuccess(result, input) {
     const barPercent = compressedContextPercent ?? contextPercent;
     const parts = [
         { text: tokensSaved != null ? `saved ${formatCompactNumber(tokensSaved)}` : "compressed" },
-        barPercent != null ? progressPart(barPercent, input, originalContextTokens) : undefined,
+        barPercent != null ? progressPart(barPercent, originalContextTokens) : undefined,
         compressedContextPercent != null && contextPercent != null ? { text: `context ${formatPercent(contextPercent)}` } : undefined,
         itemCount != null ? { text: `${itemCount} ${plural(itemCount, "item")}` } : undefined,
         summaryTokens != null ? { text: `${formatCompactNumber(summaryTokens)} summary tokens` } : undefined,
@@ -53,17 +52,9 @@ function formatCompressSuccess(result, input) {
     ].filter((part) => Boolean(part));
     return joinHeaderParts(...parts) ?? { text: "compressed" };
 }
-function progressPart(percent, input, previousContextTokens) {
+function progressPart(percent, previousContextTokens) {
     const text = `${formatCompactProgressBar(percent)} ${formatPercent(percent)}${previousContextTokens != null ? ` of ${formatCompactNumber(previousContextTokens)}` : ""}`;
-    if (!input.colors)
-        return { text };
-    return {
-        text,
-        segments: compactProgressBarSegments(0, percent, {
-            fill: input.toolColor ?? input.colors.muted,
-            track: input.colors.statusDotBase,
-        }),
-    };
+    return { text };
 }
 function inferContextTokens(contextPercent, contextWindow) {
     if (contextPercent == null || contextWindow == null || contextWindow <= 0)
@@ -80,19 +71,7 @@ function joinHeaderParts(...parts) {
     if (defined.length === 0)
         return undefined;
     const separator = " · ";
-    const segments = [];
-    let offset = 0;
-    for (const [index, part] of defined.entries()) {
-        if (index > 0)
-            offset += separator.length;
-        if (part.segments) {
-            for (const segment of part.segments) {
-                segments.push({ ...segment, start: offset + segment.start, end: offset + segment.end });
-            }
-        }
-        offset += part.text.length;
-    }
-    return { text: defined.map((part) => part.text).join(separator), segments };
+    return { text: defined.map((part) => part.text).join(separator) };
 }
 function numberValue(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;

package/dist/tool-renderers/index.js

@@ -4,6 +4,7 @@ import { renderCompressTool } from "./compress.js";
 import { renderQuestionTool } from "./question.js";
 import { renderReadTool } from "./read.js";
 import { renderRepoTool } from "./repo.js";
+import { renderSearchTool } from "./search.js";
 import { renderShellTool } from "./shell.js";
 import { applySkillReadDisplay } from "./skill.js";
 import { renderSubagentsTool } from "./subagents.js";
@@ -25,6 +26,13 @@ const TOOL_RENDERERS = {
     Write: renderWriteTool,
     ast_grep: renderAstTool,
     ast_apply: renderAstTool,
+    grep: renderSearchTool,
+    Grep: renderSearchTool,
+    rg: renderSearchTool,
+    Glob: renderSearchTool,
+    glob: renderSearchTool,
+    find: renderSearchTool,
+    Find: renderSearchTool,
     web_search: renderWebSearchTool,
     web_fetch: renderWebFetchTool,
     todo: renderTodoTool,

package/dist/tool-renderers/question.js

@@ -16,7 +16,7 @@ export const renderQuestionTool = (input) => {
     return {
         headerArgs: formatHeader(questions),
         collapsedBody: resultText,
-        ...expandedTextFromParts({ text: questionsText, color: "muted" }, { text: input.isError ? `error\n${resultText}` : resultText }),
+        ...expandedTextFromParts({ text: questionsText }, { text: input.isError ? `error\n${resultText}` : resultText }),
     };
 };
 function questionItems(value) {

package/dist/tool-renderers/search.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRendererMiddleware } from "./types.js";
+export declare const renderSearchTool: ToolRendererMiddleware;

package/dist/tool-renderers/search.js

@@ -0,0 +1,15 @@
+import { argsRecord, formatArgsInline } from "./utils.js";
+// Search tools (grep/Glob/find) show their arguments inline in the header. Rendering the
+// arguments again as a muted body block (as defaultToolRender does) would dim the first output
+// lines and duplicate the header, so these tools render the output only — like repo_* tools.
+const PREFERRED_KEYS = ["pattern", "path", "glob", "type", "output_mode", "output_line_limit", "case_sensitive", "regex", "multiline", "-n", "context", "head_limit", "max_results"];
+export const renderSearchTool = (input) => {
+    const args = argsRecord(input);
+    const result = input.output || (input.status === "running" ? "running…" : "(empty)");
+    const headerArgs = args ? formatArgsInline(args, PREFERRED_KEYS) : undefined;
+    return {
+        ...(headerArgs ? { headerArgs } : {}),
+        collapsedBody: input.output,
+        expandedText: result,
+    };
+};

package/dist/tool-renderers/skill.js

@@ -10,7 +10,7 @@ export function applySkillReadDisplay(input, rendered) {
     if (!skill)
         return rendered;
     const pathText = skill.path ?? "";
-    const expanded = expandedTextFromParts({ text: pathText, color: "muted" }, { text: resultText(input, { empty: !pathText }) });
+    const expanded = expandedTextFromParts({ text: pathText }, { text: resultText(input, { empty: !pathText }) });
     const resultStartLine = pathText ? lineCount(pathText) + 1 : 0;
     return {
         ...rendered,

package/dist/tool-renderers/types.d.ts

@@ -1,13 +1,5 @@
 import type { Theme } from "../theme.js";
 import type { ToolBodySyntaxHighlights } from "../syntax-highlight.js";
-export type ToolHeaderSegment = {
-    start: number;
-    end: number;
-    foreground?: string;
-    background?: string;
-    bold?: boolean;
-    strikethrough?: boolean;
-};
 export type ToolBodyLineStyle = {
     startLine: number;
     endLine?: number;
@@ -31,7 +23,6 @@ export type ToolRenderInput = {
 export type ToolRenderResult = {
     toolName?: string;
     headerArgs?: string;
-    headerArgsSegments?: readonly ToolHeaderSegment[];
     bodyLineStyles?: readonly ToolBodyLineStyle[];
     bodyStyle?: "diff";
     preserveAnsi?: boolean;

package/dist/tool-renderers/utils.js

@@ -70,7 +70,7 @@ export function resultSection(input) {
 export function argsAndResultExpandedText(input, argsBlock) {
     const formattedArgs = argsBlock.trimEnd();
     const showArgs = formattedArgs.length > 0 && formattedArgs !== "(empty)";
-    return expandedTextFromParts(...(showArgs ? [{ text: formattedArgs, color: "muted" }] : []), { text: resultText(input, { empty: !showArgs }) });
+    return expandedTextFromParts(...(showArgs ? [{ text: formattedArgs }] : []), { text: resultText(input, { empty: !showArgs }) });
 }
 export function resultText(input, options = {}) {
     if (input.output)

package/external/pi-tools-suite/src/codex-reasoning-fix/index.ts

@@ -0,0 +1,203 @@
+/**
+ * WORKAROUND for @earendil-works/pi-ai bug: the Codex / OpenAI Responses API
+ * rejects HTTP 400 `Unknown parameter: 'input[N].content'` when non-message
+ * items (reasoning, function_call_output) carry a spurious `content` field.
+ *
+ * Root cause is in pi-ai's `convertResponsesMessages`, which pushes replayed
+ * items verbatim including a stray `content` placeholder. The upstream fix is
+ * uncommitted in pi-mono and never shipped, so every released pi-ai version
+ * (incl. 0.79.10) is affected.
+ *
+ * The fix must run at the transport layer because the provider has TWO paths:
+ *
+ *  1. WebSocket-cached path (normal): `buildCachedWebSocketRequestBody` rebuilds
+ *     the body into a DELTA after `before_provider_request`, so the hook never
+ *     sees the bytes actually sent. We wrap `WebSocket.prototype.send` once and
+ *     strip `content` from every non-message input item of each
+ *     `response.create` frame, on the exact bytes leaving the socket.
+ *
+ *  2. SSE/fetch fallback path: once a websocket attempt fails (common at large
+ *     context — full body, ~100+ input items), the transport records an SSE
+ *     fallback for the session and every subsequent request goes through a plain
+ *     `fetch()` POST with the FULL body (`bodyJson`). The `before_provider_request`
+ *     hook should clean this, but in practice it does not reliably catch every
+ *     offending item, so we also wrap `globalThis.fetch` once and strip the same
+ *     spurious `content` from the request body on the exact bytes leaving the
+ *     HTTP client.
+ *
+ * The `before_provider_request` hook is kept as a third secondary guard.
+ *
+ * Remove this whole module once an upstream pi-ai release carries the fix.
+ */
+type ExtensionAPI = any;
+
+type ProviderRequestEvent = {
+	payload?: unknown;
+};
+
+type ProviderRequestContext = {
+	cwd?: string;
+	model?: unknown;
+};
+
+installWireStripper();
+installFetchStripper();
+
+/**
+ * Strip spurious `content` from any object that carries an `input` or
+ * `messages` array. Shared core for the wire-frame, fetch, and hook paths.
+ * Returns the cleaned object plus a tally only when something changed;
+ * otherwise `undefined` (caller forwards the original untouched).
+ */
+export function stripCarrier(obj: unknown): { obj: Record<string, unknown>; stripped: number } | undefined {
+	if (!isRecord(obj)) return undefined;
+	const field = Array.isArray(obj.input) ? "input" : Array.isArray(obj.messages) ? "messages" : null;
+	if (!field) return undefined;
+
+	const list = obj[field] as unknown[];
+	let stripped = 0;
+	let changed = false;
+	const next = new Array(list.length);
+	for (let i = 0; i < list.length; i++) {
+		const item = list[i];
+		if (isSpuriousContentItem(item)) {
+			const { content: _drop, ...rest } = item as Record<string, unknown>;
+			next[i] = rest;
+			stripped++;
+			changed = true;
+		} else {
+			next[i] = item;
+		}
+	}
+	if (!changed) return undefined;
+	return { obj: { ...obj, [field]: next }, stripped };
+}
+
+/**
+ * True only for items that carry a spurious `content`: an explicit `type` that
+ * is NOT "message". Role-based messages (no `type`) and typed messages
+ * (`type:"message"`) legitimately hold content — they are left untouched.
+ */
+function isSpuriousContentItem(item: unknown): boolean {
+	return (
+		isRecord(item) &&
+		typeof item.type === "string" &&
+		item.type !== "message" &&
+		Object.prototype.hasOwnProperty.call(item, "content")
+	);
+}
+
+/**
+ * Wrap `WebSocket.prototype.send` once. For each `response.create` frame, strip
+ * the offending `content` from non-message input items and forward the cleaned
+ * frame. Forwards the original untouched on any parse/rewrite failure so the
+ * transport never breaks.
+ */
+function installWireStripper(): void {
+	try {
+		const WS = (globalThis as { WebSocket?: typeof WebSocket }).WebSocket;
+		if (!WS?.prototype) return;
+		const proto = WS.prototype as { send?: unknown };
+		if (typeof proto.send !== "function") return;
+		const original = proto.send as (data: unknown) => void;
+		if ((original as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped) return;
+
+		const wrapped = function (this: unknown, data: unknown): void {
+			let outgoing = data;
+			if (typeof data === "string") {
+				try {
+					const parsed = JSON.parse(data);
+					if (isRecord(parsed) && parsed.type === "response.create") {
+						const result = stripCarrier(parsed);
+						if (result) {
+							outgoing = JSON.stringify(result.obj);
+						}
+					}
+				} catch {
+					// Non-JSON or malformed: forward untouched.
+				}
+			}
+			return original.call(this, outgoing);
+		};
+		(wrapped as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped = true;
+		proto.send = wrapped;
+	} catch {
+		// best-effort; never break on setup
+	}
+}
+
+/**
+ * Wrap `globalThis.fetch` once. For JSON POST bodies carrying an `input` or
+ * `messages` array (Codex / OpenAI Responses shape), strip the spurious
+ * `content` from non-message items before the request leaves the HTTP client.
+ * This closes the SSE-fallback path that the WebSocket wrapper cannot see.
+ * Forwards the original request untouched on any non-matching/parse failure.
+ */
+function installFetchStripper(): void {
+	try {
+		const g = globalThis as { fetch?: typeof fetch };
+		const original = g.fetch;
+		if (typeof original !== "function") return;
+		if ((original as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped) return;
+
+		const wrapped = function fetchStripper(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+			const nextInit = stripFetchInit(init);
+			return original.call(this, input, nextInit ?? init);
+		};
+		(wrapped as unknown as { __codexFixWrapped?: boolean }).__codexFixWrapped = true;
+		g.fetch = wrapped as typeof fetch;
+	} catch {
+		// best-effort; never break on setup
+	}
+}
+
+/**
+ * If `init` carries a JSON body shaped like a Responses request, return a new
+ * `init` with the stripped body. Returns `undefined` when nothing matched so
+ * the caller forwards the original `init` untouched.
+ */
+export function stripFetchInit(init: RequestInit | undefined): RequestInit | undefined {
+	if (!init || typeof init.body !== "string") return undefined;
+	try {
+		const parsed = JSON.parse(init.body);
+		const result = stripCarrier(parsed);
+		if (!result) return undefined;
+		return { ...init, body: JSON.stringify(result.obj) };
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * If `frame` is a Codex `response.create` carrying an `input` (or `messages`)
+ * array, return the cleaned frame plus a tally of stripped items. Returns
+ * `undefined` when nothing matched (caller forwards the original frame
+ * untouched). Exported for unit testing.
+ */
+export function stripContentFromWireFrame(frame: unknown): { frame: Record<string, unknown>; stripped: number } | undefined {
+	if (!isRecord(frame) || frame.type !== "response.create") return undefined;
+	const result = stripCarrier(frame);
+	if (!result) return undefined;
+	return { frame: result.obj, stripped: result.stripped };
+}
+
+export default function codexReasoningFix(pi: ExtensionAPI): void {
+	pi.on("before_provider_request", async (event: ProviderRequestEvent, _ctx: ProviderRequestContext) => {
+		const result = stripReasoningContentFromPayload(event.payload);
+		return result === event.payload ? undefined : result;
+	});
+}
+
+/**
+ * Strip spurious `content` from non-message items in a full payload. Secondary
+ * guard for the SSE-fallback / non-websocket path. Returns the same reference
+ * when nothing changed; exported for unit testing.
+ */
+export function stripReasoningContentFromPayload(payload: unknown): unknown {
+	const result = stripCarrier(payload);
+	return result ? result.obj : payload;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/external/pi-tools-suite/src/dcp/index.ts

@@ -532,6 +532,23 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				}, ctx)
 			}
 
+			const hasCompressionSuggestion =
+				candidate !== null || messageCandidates.length > 0
+			if (!manualEmergencyOnly && !hasCompressionSuggestion) {
+				const clearedAnchors = clearDcpNudgeAnchors(state)
+				state.consecutiveIgnoredStrongNudges = 0
+				if (clearedAnchors > 0) await saveDcpState(ctx, state)
+				if (nudgeType || clearedAnchors > 0) {
+					writeDcpDebugLog(effectiveConfig, "context.no_compression_candidate", {
+						contextPercent,
+						thresholds,
+						nudgeType,
+						clearedAnchors,
+						state: summarizeDcpState(state),
+					}, ctx)
+				}
+			}
+
 			// Track consecutive ignored context-strong nudges for the
 			// auto-compress fallback. A strong nudge is "ignored" if it fires
 			// again on a later context event without a successful compress in
@@ -539,9 +556,12 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 			// the emergency threshold (handled by the below-threshold early
 			// return above, which clears anchors; counter is also reset on any
 			// successful compress in the compress tool).
-			if (nudgeType === "context-strong" || nudgeType === "context-soft") {
+			if (
+				hasCompressionSuggestion &&
+				(nudgeType === "context-strong" || nudgeType === "context-soft")
+			) {
 				state.consecutiveIgnoredStrongNudges += 1
-			} else if (nudgeType === null) {
+			} else if (nudgeType === null || !hasCompressionSuggestion) {
 				state.consecutiveIgnoredStrongNudges = 0
 			}
 
@@ -604,7 +624,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				}
 			}
 
-			if (nudgeType && !manualEmergencyOnly) {
+			if (nudgeType && !manualEmergencyOnly && hasCompressionSuggestion) {
 				const nudgeText = appendConcreteNudgeGuidance(
 					baseNudgeText(nudgeType),
 					candidate,

package/external/pi-tools-suite/src/index.ts

@@ -10,6 +10,7 @@ type ExtensionModule = {
 };
 
 const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
+	{ name: "codex-reasoning-fix", load: () => import("./codex-reasoning-fix/index") },
 	{ name: "coding-discipline", load: () => import("./coding-discipline/index") },
 	{ name: "ast-grep", load: () => import("./ast-grep/index") },
 	{ name: "async-subagents", load: () => import("./async-subagents/index") },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.47",
+  "version": "0.1.49",
   "private": false,
   "type": "module",
   "bin": {