chore(pi-tui): sync vendored pi-tui to upstream v1.0.1

Author: elkaix

.changeset/pi-tui-upstream-v1-0-1.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Update the terminal UI library to upstream pi v1.0.1, which keeps WezTerm images while scrolling, converts non-PNG images for Kitty, and fixes ANSI color order when a styled line is cut.

packages/pi-tui/README.md

@@ -68,6 +68,91 @@ tui.requestRender(); // Request a re-render
 tui.onDebug = () => console.log("Debug triggered");
 ```
 
+### Colors and terminal styles
+
+Colors are values that can be converted or mixed before terminal rendering:
+
+```typescript
+import {
+  colorToRgb,
+  foregroundAnsi,
+  getTerminalColorMode,
+  mixColors,
+  parseColor,
+  rgbColor,
+  styleText,
+} from "@earendil-works/pi-tui";
+
+const accent = parseColor("oklch(70% 0.12 220)");
+const background = parseColor("#20242a");
+const foreground = mixColors(accent, background, 0.2);
+
+const text = styleText(
+  "Ready",
+  { fg: foreground, bg: background, bold: true },
+  getTerminalColorMode(),
+);
+```
+
+`Color` is an indexed ANSI color, an sRGB color, or an OKLCH color. Every color converts to sRGB, so color math such as `mixColors()` always works. Indices 0-15 follow the user's terminal palette, so their sRGB values are approximations. `styleText()` converts colors to truecolor or 256-color output based on the requested terminal mode.
+
+`parseColor()` also accepts OKHSL, as in `okhsl(250 60% 55%)`; `okhslColor()` builds it in code and `colorToOkhsl()` reads any color's OKHSL channels. OKHSL saturation is relative to the most the sRGB gamut allows at the hue and lightness, so every value is in gamut and equal saturation looks equally colorful across hues. OKHSL colors are converted to sRGB when created.
+
+Conversions are not cached. OKLCH colors, especially ones outside the sRGB gamut, are more expensive to convert than sRGB or indexed colors. For colors used on every render, convert once and reuse the result:
+
+```typescript
+const { r, g, b } = colorToRgb(mixColors(accent, background, 0.2));
+const foreground = rgbColor(r, g, b); // cheap to render repeatedly
+const foregroundCode = foregroundAnsi(foreground, getTerminalColorMode());
+```
+
+### Alternate-screen viewport layouts
+
+`TuiAltScreen` can render an explicit terminal-height layout. `VStack` and `HStack` allocate constrained regions, while `ScrollView` owns scrolling for one region. These semantics are intentionally unavailable on `TuiMainScreen`, where the terminal owns scrollback.
+
+```typescript
+import {
+  Container,
+  isViewportTUI,
+  ScrollView,
+  Text,
+  VStack,
+} from "@earendil-works/pi-tui";
+
+const transcript = new Container();
+transcript.addChild(new Text("History"));
+
+const editorAndFooter = new VStack([
+  editor,
+  new Text("status"),
+]);
+
+if (isViewportTUI(tui)) {
+  tui.setLayoutRoot(new VStack([
+    {
+      component: new ScrollView(transcript, {
+        follow: "end",
+        primary: true,
+        overscroll: "chain",
+      }),
+      basis: 0,
+      grow: 1,
+      minSize: 1,
+    },
+    {
+      component: editorAndFooter,
+      basis: "auto",
+      shrink: 1,
+      minSize: 1,
+    },
+  ]));
+}
+```
+
+Stack entries support `basis`, `grow`, `shrink`, `minSize`, `maxSize`, and responsive `visible` callbacks. Mouse-wheel input targets the scroll view under the pointer and unused delta chains to outer scroll views by default. The primary scroll view receives the alternate-screen keyboard navigation actions and wheel input over non-scrollable regions. It can also jump between OSC 133 semantic prompt markers, matching common terminal prompt-navigation shortcuts. Press `Ctrl+Shift+F` to open or close its bordered search panel. The panel shows the configured previous/next shortcuts and provides clickable arrow controls; by default, `Enter`/`Ctrl+G` and `Shift+Enter`/`Ctrl+Shift+G` move between matches, and `Escape` also closes search. `TuiAltScreenOptions.searchMatchStyle` and `searchCurrentMatchStyle` customize match highlighting, while `searchNavigationButtonStyle` styles each arrow button and receives its hover state. `TuiAltScreenOptions.scrollToEndIndicator` renders a clickable label centered on the last row of a `follow: "end"` primary scroll view while it is scrolled away from the end; clicking it resumes end-following.
+
+Layout geometry is rebuilt for each requested frame. Stateful components are retained, and their existing rendered-line caches remain effective. Calling `render(width)` directly on these layout components produces an unbounded document, which is also used when alt mode restores the main screen.
+
 ### Overlays
 
 Overlays render components on top of existing content without replacing it. Useful for dialogs, menus, and modal UI.
@@ -154,15 +239,17 @@ All components implement:
 interface Component {
   render(width: number): string[];
   handleInput?(data: string): void;
-  invalidate?(): void;
+  handleMouse?(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+  invalidate(): void;
 }
 ```
 
 | Method | Description |
 |--------|-------------|
 | `render(width)` | Returns an array of strings, one per line. Each line **must not exceed `width`** or the TUI will error. Use `truncateToWidth()` or manual wrapping to ensure this. |
 | `handleInput?(data)` | Called when the component has focus and receives keyboard input. The `data` string contains raw terminal input (may include ANSI escape sequences). |
-| `invalidate?()` | Called to clear any cached render state. Components should re-render from scratch on the next `render()` call. |
+| `handleMouse?(event)` | Called by `TuiAltScreen` for normalized pointer input targeted at the component. |
+| `invalidate()` | Required. Clear any cached render state so the next `render()` starts from scratch. Components without cached render state can use an empty implementation. |
 
 The TUI appends a full SGR reset and OSC 8 reset at the end of each rendered line. Styles do not carry across lines. If you emit multi-line text with styling, reapply styles per line or use `wrapTextWithAnsi()` so styles are preserved for each wrapped line.
 
@@ -181,6 +268,8 @@ class MyInput implements Component, Focusable {
     // Emit marker right before the fake cursor
     return [`> ${beforeCursor}${marker}\x1b[7m${atCursor}\x1b[27m${afterCursor}`];
   }
+
+  invalidate(): void {}
 }
 ```
 
@@ -678,6 +767,8 @@ class MyInteractiveComponent implements Component {
       return truncateToWidth(prefix + item, width);
     });
   }
+
+  invalidate(): void {}
 }
 ```
 
@@ -709,6 +800,8 @@ class MyComponent implements Component {
     // Pad to exact width (optional, for backgrounds)
     return [line + " ".repeat(width - visible)];
   }
+
+  invalidate(): void {}
 }
 ```
 
@@ -766,7 +859,7 @@ See `test/chat-simple.ts` for a complete chat interface example with:
 
 Run it:
 ```bash
-npx tsx test/chat-simple.ts
+node test/chat-simple.ts
 ```
 
 ## Development
@@ -779,13 +872,13 @@ npm install
 npm run check
 
 # Run the demo
-npx tsx test/chat-simple.ts
+node test/chat-simple.ts
 ```
 
 ### Debug logging
 
 Set `PI_TUI_WRITE_LOG` to capture the raw ANSI stream written to stdout.
 
 ```bash
-PI_TUI_WRITE_LOG=/tmp/tui-ansi.log npx tsx test/chat-simple.ts
+PI_TUI_WRITE_LOG=/tmp/tui-ansi.log node test/chat-simple.ts
 ```

packages/pi-tui/UPSTREAM.md

@@ -8,7 +8,8 @@ Update this section after every sync. Do not reuse the previous range.
 
 - **Repo:** `https://github.com/earendil-works/pi.git`
 - **Subtree:** `packages/tui`
-- **Commit:** `53816d7dcc5ebe3a0eedec3cd07196c3a66d83fd` (2026-09-14; v0.85.1 plus upstream main through this commit)
+- **Commit:** `a7229ddc21810d6245105978033b7df645ecc2f7` (2026-10-03; upstream tag v1.0.1)
+- **Darwin prebuilds:** rebuilt locally from `native/darwin/src/darwin-platform.m` with `native/darwin/build.sh`, not copied from upstream. Exports and linked libraries match the upstream v1.0.1 prebuilds.
 - **This commit is an upstream marker.** It may not exist in this repo's object database.
 
 ## Reconstruct the fork

packages/pi-tui/native/clipboard.h

@@ -7,8 +7,17 @@
 #include <string.h>
 #endif
 
-typedef enum { CLIPBOARD_TEXT, CLIPBOARD_IMAGE, CLIPBOARD_WRITE } clipboard_operation;
-typedef enum { CLIPBOARD_UNAVAILABLE, CLIPBOARD_EMPTY, CLIPBOARD_UTF8, CLIPBOARD_LATIN1, CLIPBOARD_UTF16, CLIPBOARD_BUFFER } clipboard_format;
+typedef enum { CLIPBOARD_TEXT, CLIPBOARD_IMAGE, CLIPBOARD_WRITE, CLIPBOARD_FILES } clipboard_operation;
+// CLIPBOARD_PATHS stores concatenated, NUL-terminated UTF-8 paths in clipboard_job.data.
+typedef enum {
+    CLIPBOARD_UNAVAILABLE,
+    CLIPBOARD_EMPTY,
+    CLIPBOARD_UTF8,
+    CLIPBOARD_LATIN1,
+    CLIPBOARD_UTF16,
+    CLIPBOARD_BUFFER,
+    CLIPBOARD_PATHS
+} clipboard_format;
 
 typedef struct {
     napi_async_work work;
@@ -63,6 +72,33 @@ static void PI_NAPI_CALL execute_clipboard_work(napi_env env, void* data) {
     clipboard_execute(data);
 }
 
+static int create_clipboard_paths_value(
+    napi_env env,
+    const clipboard_job* job,
+    napi_create_string_utf8_fn create_string,
+    napi_value* result
+) {
+    napi_create_array_fn create_array = (napi_create_array_fn)node_symbol("napi_create_array");
+    napi_set_element_fn set_element = (napi_set_element_fn)node_symbol("napi_set_element");
+    if (!create_array || !set_element || create_array(env, result) != 0) return 1;
+
+    const char* cursor = job->data;
+    const char* end = cursor + job->length;
+    for (uint32_t index = 0; cursor < end; index++) {
+        const char* terminator = cursor;
+        while (terminator < end && *terminator != '\0') terminator++;
+        if (terminator == end) return 1;
+
+        napi_value item = 0;
+        if (create_string(env, cursor, (size_t)(terminator - cursor), &item) != 0 ||
+            set_element(env, *result, index, item) != 0) {
+            return 1;
+        }
+        cursor = terminator + 1;
+    }
+    return 0;
+}
+
 static void PI_NAPI_CALL complete_clipboard_work(napi_env env, int status, void* data) {
     clipboard_job* job = data;
     napi_create_string_utf8_fn create_string = (napi_create_string_utf8_fn)node_symbol("napi_create_string_utf8");
@@ -71,6 +107,8 @@ static void PI_NAPI_CALL complete_clipboard_work(napi_env env, int status, void*
     if (!job->error && job->operation != CLIPBOARD_WRITE) {
         if (job->format == CLIPBOARD_EMPTY) {
             result = null_value(env);
+        } else if (job->format == CLIPBOARD_PATHS) {
+            status = create_clipboard_paths_value(env, job, create_string, &result);
         } else if (job->format == CLIPBOARD_BUFFER) {
             napi_create_buffer_copy_fn create_buffer = (napi_create_buffer_copy_fn)node_symbol("napi_create_buffer_copy");
             status = create_buffer(env, job->length, job->data, 0, &result);

packages/pi-tui/native/darwin/README.md

@@ -1,6 +1,6 @@
 # Darwin native prebuilds
 
-Provides modifier-key state and asynchronous text/image clipboard access using AppKit.
+Provides modifier-key state and asynchronous text, image, and file-path clipboard access using AppKit.
 
 ## Building
 

packages/pi-tui/native/darwin/prebuilds/darwin-arm64/darwin-platform.node

@@ -66,6 +66,40 @@ static void clipboard_execute(clipboard_job* job) {
             } else {
                 clipboard_copy(job, text.UTF8String, [text lengthOfBytesUsingEncoding:NSUTF8StringEncoding], CLIPBOARD_UTF8);
             }
+        } else if (job->operation == CLIPBOARD_FILES) {
+            NSArray* urls = [pasteboard readObjectsForClasses:@[[NSURL class]]
+                options:@{NSPasteboardURLReadingFileURLsOnlyKey: @YES}];
+            size_t total = 0;
+            for (NSURL* url in urls) {
+                const char* path = url.fileSystemRepresentation;
+                if (!path) continue;
+                size_t length = strlen(path);
+                if (length == SIZE_MAX || total > SIZE_MAX - length - 1) {
+                    job->error = "Clipboard file paths are too large";
+                    return;
+                }
+                total += length + 1;
+            }
+            if (total == 0) {
+                job->format = CLIPBOARD_EMPTY;
+                return;
+            }
+            char* paths = clipboard_alloc(total);
+            if (!paths) {
+                job->error = "Out of memory";
+                return;
+            }
+            char* cursor = paths;
+            for (NSURL* url in urls) {
+                const char* path = url.fileSystemRepresentation;
+                if (!path) continue;
+                size_t length = strlen(path);
+                memcpy(cursor, path, length + 1);
+                cursor += length + 1;
+            }
+            job->data = paths;
+            job->length = total;
+            job->format = CLIPBOARD_PATHS;
         } else {
             if (![pasteboard availableTypeFromArray:@[ NSPasteboardTypePNG, NSPasteboardTypeTIFF ]]) {
                 job->format = CLIPBOARD_EMPTY;
@@ -84,10 +118,15 @@ static void clipboard_execute(clipboard_job* job) {
     }
 }
 
+static napi_value PI_NAPI_CALL get_clipboard_file_paths(napi_env env, napi_callback_info info) {
+    return queue_clipboard(env, info, CLIPBOARD_FILES);
+}
+
 PI_NAPI_EXPORT napi_value napi_register_module_v1(napi_env env, napi_value exports) {
     set_function_export(env, exports, "isModifierPressed", is_modifier_pressed);
     set_function_export(env, exports, "getText", get_clipboard_text);
     set_function_export(env, exports, "setText", set_clipboard_text);
     set_function_export(env, exports, "getImage", get_clipboard_image);
+    set_function_export(env, exports, "getFilePaths", get_clipboard_file_paths);
     return exports;
 }

packages/pi-tui/native/darwin/prebuilds/darwin-x64/darwin-platform.node

@@ -26,6 +26,7 @@ typedef void* napi_deferred;
 typedef void (PI_NAPI_CALL *napi_async_execute_callback)(napi_env, void*);
 typedef void (PI_NAPI_CALL *napi_async_complete_callback)(napi_env, int, void*);
 typedef int (PI_NAPI_CALL *napi_create_async_work_fn)(napi_env, napi_value, napi_value, napi_async_execute_callback, napi_async_complete_callback, void*, napi_async_work*);
+typedef int (PI_NAPI_CALL *napi_create_array_fn)(napi_env, napi_value*);
 typedef int (PI_NAPI_CALL *napi_async_work_fn)(napi_env, napi_async_work);
 typedef int (PI_NAPI_CALL *napi_create_promise_fn)(napi_env, napi_deferred*, napi_value*);
 typedef int (PI_NAPI_CALL *napi_settle_deferred_fn)(napi_env, napi_deferred, napi_value);
@@ -41,6 +42,7 @@ typedef int (PI_NAPI_CALL *napi_get_value_fn)(napi_env, napi_value*);
 typedef int (PI_NAPI_CALL *napi_get_value_string_utf8_fn)(napi_env, napi_value, char*, size_t, size_t*);
 typedef int (PI_NAPI_CALL *napi_get_value_string_utf16_fn)(napi_env, napi_value, uint16_t*, size_t, size_t*);
 typedef int (PI_NAPI_CALL *napi_set_named_property_fn)(napi_env, napi_value, const char*, napi_value);
+typedef int (PI_NAPI_CALL *napi_set_element_fn)(napi_env, napi_value, uint32_t, napi_value);
 typedef int (PI_NAPI_CALL *napi_throw_error_fn)(napi_env, const char*, const char*);
 
 static void* node_symbol(const char* name) {