pum-agent 0.2.23-beta.1 → 0.2.25-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pum-agent",
-  "version": "0.2.23-beta.1",
+  "version": "0.2.25-beta.1",
   "description": "A compact terminal coding agent powered by pi and OpenTUI.",
   "license": "MIT",
   "type": "module",

package/src/app.tsx

@@ -52,10 +52,12 @@ import {
   needsTranscriptGap,
   topAnchorScrollTop,
   PendingMessageLine,
+  flushStream,
   rawToolText,
   resolveGoalReview,
   resolvePendingDelivery,
   settleTranscriptMessage,
+  streamedDelta,
   StreamLine,
   TextLine,
   ToolLine,
@@ -310,8 +312,14 @@ const QUIT_WINDOW_MS = 2000;
 const MAX_INPUT_ROWS = 8;
 /** How long a scroll to a row waits between tries for React to draw it. */
 const ROW_DRAW_RETRY_MS = 30;
-/** How many of those tries it makes before it gives up. */
-const ROW_DRAW_TRIES = 12;
+/**
+ * How many of those tries it makes before it gives up.
+ *
+ * A busy machine with a long session can take most of a second to draw a row
+ * that had to be mounted first, and a jump that gives up before then looks to
+ * the reader exactly like a dead key.
+ */
+const ROW_DRAW_TRIES = 30;
 /** Frames a scroll correction waits for its rows before it gives up. */
 const ANCHOR_FRAME_BUDGET = 30;
 /** Keys that move around without changing the text. */
@@ -731,11 +739,7 @@ const DEFAULT_PROMPT_STASH_STORE: PromptStashStore = {
 
 /** Move any buffered stream into the transcript so later lines land in order. */
 function flushed(t: Transcript): Transcript {
-  if (t.stream && t.stream.text.trim()) {
-    const line: Line = { kind: "text", role: t.stream.kind, text: t.stream.text.trim() };
-    return { lines: [...t.lines, line], stream: null, pending: t.pending };
-  }
-  return { ...t, stream: null };
+  return flushStream(t);
 }
 
 export function App({
@@ -1882,10 +1886,7 @@ export function App({
   }, [activeAgentId, agents.map((agent) => agent.id).join(":")]);
 
   const delta = (kind: "assistant" | "thinking", text: string) =>
-    setTx((t) => {
-      if (t.stream?.kind === kind) return { ...t, stream: { kind, text: t.stream.text + text } };
-      return { ...flushed(t), stream: { kind, text } };
-    });
+    setTx((t) => streamedDelta(t, kind, text));
 
   const patchTool = (id: string, patch: Partial<ToolCall>) =>
     setTx((t) => ({

package/src/cli.ts

@@ -229,8 +229,8 @@ session history, Ctrl+T for triggers, and Ctrl+C twice on an empty prompt to qui
 Configuration:
   PUM stores credentials, settings, and sessions in its own configuration
   directory. Set PUM_DIR to override the complete directory. Defaults are
-  $XDG_CONFIG_HOME/pum or ~/.config/pum on Linux, ~/Library/Application Support/pum
-  on macOS, and %LOCALAPPDATA%\\pum on Windows.
+  $XDG_CONFIG_HOME/pum or ~/.config/pum on Linux and Windows, and
+  ~/Library/Application Support/pum on macOS.
 
 Package: ${metadata.name}
 Executable: pum

package/src/platform.ts

@@ -19,11 +19,9 @@ export function defaultAgentDir(
 ): string {
   const paths = pathApi(platform);
   if (env.PUM_DIR) return paths.resolve(env.PUM_DIR);
-  if (platform === "win32") {
-    const base = env.LOCALAPPDATA ?? env.APPDATA ?? paths.join(home, "AppData", "Local");
-    return paths.join(base, "pum");
-  }
   if (platform === "darwin") return paths.join(home, "Library", "Application Support", "pum");
+  // Windows shares the Linux layout on purpose: one path to document, and a
+  // config directory the user can find and back up next to their other tools.
   return paths.join(env.XDG_CONFIG_HOME ?? paths.join(home, ".config"), "pum");
 }
 

package/src/subagents/manager.ts

@@ -68,8 +68,10 @@ import type { SandboxMode } from "../sandbox/types";
 import { readBranch } from "../git-branch";
 import { GOAL_VERDICT_TOOL_NAME, goalVerdictParameters } from "../goal-judge";
 import {
+  flushStream,
   resolvePendingDelivery,
   settleTranscriptMessage,
+  streamedDelta,
   type Line,
   type PendingLine,
 } from "../transcript";
@@ -314,15 +316,7 @@ type ManagerOptions = {
 const emptyTranscript = (): AgentTranscript => ({ lines: [], stream: null, pending: [] });
 
 function flushTranscript(transcript: AgentTranscript): AgentTranscript {
-  if (!transcript.stream?.text.trim()) return { ...transcript, stream: null };
-  return {
-    lines: [
-      ...transcript.lines,
-      { kind: "text", role: transcript.stream.kind, text: transcript.stream.text.trim() },
-    ],
-    stream: null,
-    pending: transcript.pending,
-  };
+  return flushStream(transcript);
 }
 
 function snapshotMetadata(snapshot: SubagentSnapshot): Omit<SubagentSnapshot, "transcript"> {
@@ -981,13 +975,7 @@ export class SubagentManager {
         if (kind === "assistant" && record.completionMessageIds?.size) {
           record.completionResponse = (record.completionResponse ?? "") + update.delta;
         }
-        this.updateTranscript(record, (value) => {
-          if (value.stream?.kind === kind) {
-            return { ...value, stream: { kind, text: value.stream.text + update.delta } };
-          }
-          const flushed = flushTranscript(value);
-          return { ...flushed, stream: { kind, text: update.delta } };
-        });
+        this.updateTranscript(record, (value) => streamedDelta(value, kind, update.delta));
         break;
       }
       case "tool_execution_start":

package/src/text-wrap.ts

@@ -0,0 +1,84 @@
+/**
+ * Wrapping that breaks at spaces only.
+ *
+ * OpenTUI's `wrapMode="word"` also breaks after `.`, `,`, `:`, `-`, `/` and
+ * `(`. In reasoning text, which is dense with file names, flags and paths,
+ * that puts `auth.` and `json` on two rows, and reads as a linebreak in the
+ * middle of a word. Pre-wrapped text leaves the renderer nothing to break.
+ */
+
+/** OpenTUI paints one tab as two columns, not as a jump to a tab stop. */
+const TAB = "  ";
+
+/** Columns a run of text occupies on screen. */
+export function textColumns(text: string): number {
+  return Bun.stringWidth(text.replaceAll("\t", TAB));
+}
+
+/**
+ * Break `text` into rows of at most `width` columns, at spaces only.
+ *
+ * A word wider than the whole row is split, because no break point exists.
+ * Existing line breaks and leading indentation are kept.
+ */
+export function wrapAtSpaces(text: string, width: number): string {
+  if (!Number.isFinite(width) || width < 1) return text;
+  const rows: string[] = [];
+  for (const line of text.split("\n")) rows.push(...wrapLine(line, width));
+  return rows.join("\n");
+}
+
+function wrapLine(line: string, width: number): string[] {
+  if (textColumns(line) <= width) return [line];
+  const rows: string[] = [];
+  // Whitespace runs are kept as their own segments, so the indentation of a
+  // code line survives and two words never lose the space between them.
+  const segments = line.split(/(\s+)/);
+  let row = "";
+  let gap = "";
+  const flush = () => {
+    if (row.length > 0) rows.push(row);
+    row = "";
+    gap = "";
+  };
+  for (const segment of segments) {
+    if (segment.length === 0) continue;
+    if (/^\s+$/.test(segment)) {
+      // Indentation belongs to the row it opens; a gap between two words is
+      // only paid for when the following word fits on the same row.
+      if (row.length === 0) row = segment;
+      else gap = segment;
+      continue;
+    }
+    if (textColumns(row + gap + segment) <= width) {
+      row += gap + segment;
+      gap = "";
+      continue;
+    }
+    flush();
+    if (textColumns(segment) <= width) {
+      row = segment;
+      continue;
+    }
+    const pieces = splitWord(segment, width);
+    rows.push(...pieces.slice(0, -1));
+    row = pieces[pieces.length - 1]!;
+  }
+  flush();
+  return rows.length > 0 ? rows : [line];
+}
+
+/** Cut a word that cannot fit any row into row-sized pieces. */
+function splitWord(word: string, width: number): string[] {
+  const pieces: string[] = [];
+  let piece = "";
+  for (const char of word) {
+    if (textColumns(piece + char) > width && piece.length > 0) {
+      pieces.push(piece);
+      piece = "";
+    }
+    piece += char;
+  }
+  if (piece.length > 0) pieces.push(piece);
+  return pieces;
+}

package/src/transcript.tsx

@@ -2,13 +2,14 @@ import {
   StyledText,
   TextAttributes,
   fg,
+  type BoxRenderable,
   type MarkdownRenderable,
   type MouseEvent as OpenTuiMouseEvent,
   type SyntaxStyle,
   type TextChunk,
   type TextRenderable,
 } from "@opentui/core";
-import type { MarkdownProps } from "@opentui/react";
+import { useRenderer, type MarkdownProps } from "@opentui/react";
 import { useEffect, useRef, useState, type RefObject } from "react";
 import {
   useBlinkingText,
@@ -22,6 +23,7 @@ import {
   goalReviewHeadline,
   type GoalReviewStatus,
 } from "./goal-review";
+import { wrapAtSpaces } from "./text-wrap";
 import type { Theme } from "./theme";
 import { bashOutputWindow, type BashOutputWindow, type ToolCall } from "./tool-line";
 import type { TranscriptOutputMode } from "./transcript-output";
@@ -158,10 +160,65 @@ export function resolveGoalReview<T extends PendingTranscriptState>(
 }
 
 /** Finish the stream, then insert messages that arrived while it was active. */
+/**
+ * The line a buffered stream becomes, or nothing when it holds no text.
+ *
+ * Reasoning keeps its text as it arrived. The rest of it can still turn up
+ * after the answer has started, and it is appended to this line, so a space at
+ * the join has to survive; the row normalizes what it shows anyway. An answer
+ * is markdown, where leading whitespace would open a code block, so it is
+ * trimmed.
+ */
+export function streamedLine(stream: PendingTranscriptState["stream"]): Line | null {
+  if (!stream?.text.trim()) return null;
+  const text = stream.kind === "thinking" ? stream.text : stream.text.trim();
+  return { kind: "text", role: stream.kind, text };
+}
+
+/** Move any buffered stream into the transcript, and close the stream. */
+export function flushStream<T extends PendingTranscriptState>(value: T): T {
+  const line = streamedLine(value.stream);
+  if (!line) return { ...value, stream: null };
+  return { ...value, lines: [...value.lines, line], stream: null };
+}
+
+/**
+ * Take one streamed delta of `kind` into the transcript.
+ *
+ * A reasoning provider does not always finish one stream before it starts the
+ * other: the last of the reasoning can arrive after the first words of the
+ * answer. Committing the answer to make room for it would cut the answer in
+ * two, which reads as a line break in the middle of a sentence. So the answer
+ * keeps the stream, and the late reasoning rejoins the row it belongs to.
+ */
+export function streamedDelta<T extends PendingTranscriptState>(
+  value: T,
+  kind: "assistant" | "thinking",
+  text: string,
+): T {
+  if (value.stream?.kind === kind) {
+    return { ...value, stream: { kind, text: value.stream.text + text } };
+  }
+  if (kind === "thinking" && value.stream?.kind === "assistant") {
+    return { ...value, lines: withThinkingAppended(value.lines, text) };
+  }
+  return { ...flushStream(value), stream: { kind, text } };
+}
+
+/** Add reasoning to the row it came from, or start one if there is none. */
+function withThinkingAppended(lines: readonly Line[], text: string): Line[] {
+  const last = lines[lines.length - 1];
+  if (last?.kind === "text" && last.role === "thinking") {
+    return [...lines.slice(0, -1), { ...last, text: last.text + text }];
+  }
+  return [...lines, { kind: "text", role: "thinking", text }];
+}
+
 export function settleTranscriptMessage<T extends PendingTranscriptState>(value: T): T {
   const lines = [...value.lines];
-  if (value.stream?.text.trim()) {
-    lines.push({ kind: "text", role: value.stream.kind, text: value.stream.text.trim() });
+  const streamed = streamedLine(value.stream);
+  if (streamed) {
+    lines.push(streamed);
   }
   const delivered = value.pending.filter((item) => item.delivered);
   return {
@@ -237,6 +294,40 @@ export function normalizeThinkingText(text: string): string {
     .replace(/\n[ \t]*\n+/g, "\n");
 }
 
+/**
+ * Columns the message body of a row occupies, or 0 before it is measured.
+ *
+ * The row is pre-wrapped at this width, so the renderer's own word wrap finds
+ * nothing to break. Layout runs before effects, so the first measurement is
+ * already the real one; the terminal's resize event covers every later one,
+ * because a resized row re-lays out without React rendering it again.
+ */
+function useBodyColumns(ref: RefObject<BoxRenderable | null>, active: boolean): number {
+  const renderer = useRenderer();
+  const [columns, setColumns] = useState(0);
+  useEffect(() => {
+    if (!active) return;
+    const measure = () => {
+      const width = ref.current?.width ?? 0;
+      if (width > 0) setColumns((current) => (current === width ? current : width));
+    };
+    measure();
+    renderer.on("resize", measure);
+    return () => { renderer.off("resize", measure); };
+  }, [active, ref, renderer]);
+  return active ? columns : 0;
+}
+
+/**
+ * Reasoning text as the row shows it: wrapped at spaces only.
+ *
+ * A caret rides the last character, so it needs a column of its own. Without
+ * one, the last word jumps to the next row the moment the caret appears.
+ */
+function thinkingDisplayText(text: string, columns: number, caret: boolean): string {
+  return wrapAtSpaces(normalizeThinkingText(text), caret ? columns - 1 : columns);
+}
+
 export function roleColor(theme: Theme, role: Role): string {
   switch (role) {
     case "user":
@@ -262,6 +353,7 @@ function Row({
   glyph,
   glyphColor,
   glyphRef,
+  bodyRef,
   background,
   onGlyphClick,
   children,
@@ -270,6 +362,8 @@ function Row({
   glyphColor: string;
   /** An animated gutter glyph writes its own content through this ref. */
   glyphRef?: RefObject<TextRenderable | null>;
+  /** A row that wraps its own text measures the message column through this. */
+  bodyRef?: RefObject<BoxRenderable | null>;
   background?: string;
   onGlyphClick?: (event: OpenTuiMouseEvent) => void;
   children: React.ReactNode;
@@ -299,7 +393,7 @@ function Row({
       </box>
       {/* The nested flex item gives every transcript type the same measured
           remaining-width column as the tool-row body. */}
-      <box style={{ flexDirection: "row", flexGrow: 1, flexShrink: 1, minWidth: 0 }}>
+      <box ref={bodyRef} style={{ flexDirection: "row", flexGrow: 1, flexShrink: 1, minWidth: 0 }}>
         {children}
       </box>
     </box>
@@ -353,7 +447,12 @@ export function TextLine({
   const color = roleColor(theme, role);
   const isUser = role === "user";
   const isAssistant = role === "assistant";
-  const displayText = role === "thinking" ? normalizeThinkingText(text) : text;
+  const isThinking = role === "thinking";
+  const bodyRef = useRef<BoxRenderable>(null);
+  const columns = useBodyColumns(bodyRef, isThinking);
+  const displayText = isThinking
+    ? thinkingDisplayText(text, columns, workingCaret)
+    : text;
   const textCaret = useBlinkingText({
     chunks: [fg(color)(displayText)],
     contentKey: `${role}:${displayText}`,
@@ -395,7 +494,7 @@ export function TextLine({
   }
 
   return (
-    <Row glyph={GUTTER} glyphColor={color}>
+    <Row glyph={GUTTER} glyphColor={color} bodyRef={isThinking ? bodyRef : undefined}>
       <text
         ref={workingCaret ? textCaret : undefined}
         // The caret hook repaints this imperatively on the frame clock. Passing
@@ -424,7 +523,11 @@ export function StreamLine({
   text: string;
 }) {
   const color = roleColor(theme, role);
-  const displayText = role === "thinking" ? normalizeThinkingText(text) : text;
+  const isThinking = role === "thinking";
+  const bodyRef = useRef<BoxRenderable>(null);
+  const columns = useBodyColumns(bodyRef, isThinking);
+  // The shimmer always carries a caret, so the row always reserves its column.
+  const displayText = isThinking ? thinkingDisplayText(text, columns, true) : text;
   const shimmer = useShimmerText({
     text: displayText,
     color,
@@ -436,7 +539,7 @@ export function StreamLine({
   const markdown = useMarkdownCaret(text, role === "assistant");
 
   return (
-    <Row glyph={GUTTER} glyphColor={color}>
+    <Row glyph={GUTTER} glyphColor={color} bodyRef={isThinking ? bodyRef : undefined}>
       {role === "assistant" ? (
         <SelectableMarkdown
           ref={markdown.ref}