@xzzpig/pi-tidy 0.1.0 → 0.1.1

package/FORK-CHANGELOG.md

@@ -3,6 +3,21 @@
 Changes specific to `@xzzpig/pi-tidy` in this repository. Upstream history remains in
 [`CHANGELOG.md`](./CHANGELOG.md).
 
+## 0.1.1 — Native thinking and renderer switch fixes
+
+- Add fork-only `nativeThinking` (default `true`): leave thinking to Pi and `pi-thinking-collapse`
+  instead of drawing pi-tidy's own row; set `false` to restore the upstream thinking row. The
+  framed final reply still keeps completed thinking outside its border.
+- Initialize the renderer switches even when tool framing is off. `groupTools: false` reached the
+  boundary renderer only through the disabled tool-frame patch, so it kept the default `true` and
+  treated a thinking + tool-use assistant as a group carrier: the thinking row vanished when the
+  first tool call arrived. The fork now publishes `groupTools`, `icons`, `thinkingColor` and the
+  native-thinking switch itself when `frameTools` is off.
+- Guard the group-boundary renderer against nested installs: only the outermost wrapper restyles a
+  component and inner wrappers pass through. `pi-group-collapse` installs its render projection
+  between pi-tidy's load-time and `before_agent_start` boundary installs; without the guard both
+  wrappers remap the same rows and a retry error draws its `error ×2` frame twice.
+
 ## 0.1.0 — Initial fork
 
 Forked from Andy8647/pi-tidy v0.9.6.
@@ -24,8 +39,3 @@ Forked from Andy8647/pi-tidy v0.9.6.
   `~/.pi/extensions/pi-tool-display/config.json`.
 - Do not restore the tool-frame path-copy chip; it lives on a frame that this fork disables by
   default.
-- Guard the group-boundary renderer against nested installs: only the outermost wrapper restyles a
-  component and inner wrappers pass through. `pi-group-collapse` installs its render projection
-  between pi-tidy's load-time and `before_agent_start` boundary installs; without the guard both
-  wrappers remap the same rows and a retry error draws its `error ×2` frame twice.
-

package/README.md

@@ -107,6 +107,7 @@ when the corresponding key is omitted:
 | Setting | Fork default | Notes |
 |---------|--------------|-------|
 | `frameTools` | `false` | Fork-only switch. `pi-tool-display` owns tool frames; set `true` only when you want pi-tidy's frames instead. |
+| `nativeThinking` | `true` | Fork-only switch. Leaves thinking to Pi and `pi-thinking-collapse` (which owns the collapsed affordance); set `false` to let pi-tidy draw its own thinking row instead. |
 | `frameMessages` | `true` | Enabled with user-message `frame` because the upstream uses this switch for both; compaction, branch, skill and custom message boxes are therefore framed too. |
 | `collapseTurns` | `"off"` | Group/turn folding remains owned by the other installed extensions. |
 | `groupTools` | `false` | Tool grouping is opt-in. |

package/fork/defaults.ts

@@ -7,6 +7,8 @@ import { loadConfig, type TidyConfig } from "../src/config.ts";
 export interface ForkTidyConfig extends TidyConfig {
   /** Draw pi-tidy's own tool frames. The fork leaves them to pi-tool-display by default. */
   frameTools: boolean;
+  /** Leave thinking rendering to Pi and pi-thinking-collapse instead of tidy's own row. */
+  nativeThinking: boolean;
 }
 
 export type ForkSettingsFile = {
@@ -20,6 +22,11 @@ function asRecord(value: unknown): RecordLike | undefined {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? (value as RecordLike) : undefined;
 }
 
+/** Settings values are decoded once at this I/O boundary. */
+function readBoolean(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}
+
 function readSettings(): ForkSettingsFile | undefined {
   try {
     const agentDir = process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
@@ -51,7 +58,8 @@ export function applyForkDefaults(
 
   return {
     ...config,
-    frameTools: typeof userOptions.frameTools === "boolean" ? userOptions.frameTools : false,
+    frameTools: readBoolean(userOptions.frameTools) ?? false,
+    nativeThinking: readBoolean(userOptions.nativeThinking) ?? true,
     highlightBash: configuredOr("highlightBash", false),
     frameMessages: configuredOr("frameMessages", true),
     userMessageStyle: configuredOr("userMessageStyle", "frame"),

package/fork/install.ts

@@ -1,15 +1,25 @@
 import { InteractiveMode, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { patchToolBoxFrames, type ToolFrameOptions } from "../src/frame.ts";
 import { installHoverTracking } from "../src/hover.ts";
+import { setGroupingActive, setIconsEnabled, setNativeThinking, setThinkingColor } from "../src/tools/tool-group-view.ts";
 import type { ForkTidyConfig } from "./defaults.ts";
 import { installForkThinkingRows } from "./thinking-row.ts";
 
 export interface ForkToolFrameInstallers {
   patchToolBoxFrames(options: ToolFrameOptions): void;
   installHoverTracking(): void;
+  setGroupingActive?(active: () => boolean): void;
+  setIconsEnabled?(icons: () => boolean): void;
+  setThinkingColor?(color: () => string): void;
 }
 
-const upstreamInstallers: ForkToolFrameInstallers = { patchToolBoxFrames, installHoverTracking };
+const upstreamInstallers: ForkToolFrameInstallers = {
+  patchToolBoxFrames,
+  installHoverTracking,
+  setGroupingActive,
+  setIconsEnabled,
+  setThinkingColor,
+};
 let errorHookWarningSent = false;
 
 function warnIfErrorHookIsUnavailable(pi: ExtensionAPI, config: ForkTidyConfig): void {
@@ -49,10 +59,22 @@ export function installForkToolFrames(
   installers: ForkToolFrameInstallers = upstreamInstallers,
 ): void {
   warnIfErrorHookIsUnavailable(pi, config);
+  // This fork leaves thinking rendering to Pi and pi-thinking-collapse.
+  setNativeThinking(() => config.nativeThinking);
   if (config.enabled && config.finalReplyStyle !== "off") {
     // index.ts registers pi-tidy's own boundary installer first, so this runs after it.
     pi.on("before_agent_start", () => installForkThinkingRows());
   }
   if (config.frameTools) installers.patchToolBoxFrames(toolFrameOptions(config));
-  else installers.installHoverTracking();
+  else {
+    // patchToolBoxFrames normally publishes the runtime switches the boundary
+    // renderer reads. With framing off it never runs, and the `groupingActive`
+    // default (true) would make a thinking+tool-use assistant render as a group
+    // carrier with no group — the thinking row silently disappeared when a tool
+    // call arrived. Publish the real values here so renderers follow the config.
+    installers.setGroupingActive?.(() => config.groupTools);
+    installers.setIconsEnabled?.(() => config.icons);
+    installers.setThinkingColor?.(() => config.thinkingColor);
+    installers.installHoverTracking();
+  }
 }

package/fork/thinking-row.ts

@@ -110,21 +110,16 @@ function thinkingRegions(component: AssistantMessageComponent): MouseRegion[] {
   return childComponents(component).filter(isMouseRegion);
 }
 
-function hasHiddenThinking(component: AssistantMessageComponent): boolean {
-  return assistantInternals(component).hideThinkingBlock === true;
-}
 
 function buildThinkingRows(
   component: AssistantMessageComponent,
   width: number,
 ): ThinkingRows | undefined {
-  // pi-tidy's framed-final-reply path intentionally omits thinking children.
-  // Restore only the settled, hidden Pi MouseRegions: streaming output remains
-  // owned by Pi and the row keeps Pi's own click-to-expand behavior.
-  if (
-    !isFramedFinalReply(component) ||
-    !hasHiddenThinking(component)
-  ) {
+  // pi-tidy's framed-final-reply path omits thinking children. Restore the
+  // settled Pi MouseRegions outside the frame whether or not Pi hides them:
+  // pi-thinking-collapse decides the collapsed affordance, and this fork never
+  // restyles thinking itself.
+  if (!isFramedFinalReply(component)) {
     return undefined;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xzzpig/pi-tidy",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "Tool folding for the pi agent — a reply's tool calls collapse to one clickable line; failures, edit diffs and running jobs stay visible",
   "license": "MIT",

package/src/tools/tool-group-view.ts

@@ -820,6 +820,13 @@ type RenderFn = ((this: any, ...args: any[]) => string[]) & { [BOUNDARY_WRAPPER]
 /** Whether grouping is on right now (the tool patch keeps this current). */
 let groupingActive: () => boolean = () => true;
 
+/** Leave Pi's own thinking rows untouched (fork native-thinking mode). */
+let nativeThinking: () => boolean = () => false;
+
+export function setNativeThinking(active: () => boolean): void {
+  nativeThinking = active;
+}
+
 /** Whether Nerd Font icons are on (`icons: false` on a terminal without one). */
 let iconsEnabled: () => boolean = () => true;
 /** `tidy.thinkingColor`: the brain, the count and an expanded box border. */
@@ -940,6 +947,7 @@ function restyleThinking(component: any, lines: string[] | undefined, width: num
     for (let i = 0; i < runs.length; i++) if (!overrides?.has?.(i)) overrides?.set?.(i, true);
   }
 
+  if (!hideThinking && nativeThinking()) return lines ?? [];
   const icons = iconsEnabled();
   const color = thinkingColorFor();
   // Keep the existing live preview/spinner; only its layout ownership changes.