mini-coder 0.5.5 → 0.5.7

package/src/submit.ts

@@ -204,12 +204,63 @@ export function resolveRawInput(
   }
 }
 
+function recordRawPromptHistory(
+  rawInput: string,
+  state: Pick<AppState, "db" | "cwd">,
+  sessionId: string,
+): void {
+  appendPromptHistory(state.db, {
+    text: rawInput,
+    cwd: state.cwd,
+    sessionId,
+  });
+  truncatePromptHistory(state.db, MAX_PROMPT_HISTORY);
+}
+
+/**
+ * Queue resolved user content for the next model-request boundary of an active run.
+ *
+ * The raw prompt is recorded immediately in prompt history, but the model-visible
+ * `UserMessage` is only appended to session history when the agent loop consumes it.
+ *
+ * @param rawInput - Exact raw submitted prompt text.
+ * @param content - Resolved model-visible user content.
+ * @param state - Mutable application state.
+ */
+export function queueResolvedInput(
+  rawInput: string,
+  content: UserMessage["content"],
+  state: AppState,
+): void {
+  if (!state.running) {
+    throw new Error("Cannot queue input while no turn is running.");
+  }
+  if (isEmptyUserContent(content)) {
+    throw new Error("Cannot queue empty input.");
+  }
+
+  const session = ensureSession(state);
+  recordRawPromptHistory(rawInput, state, session.id);
+  state.queuedUserMessages.push({
+    role: "user",
+    content,
+    timestamp: Date.now(),
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Turn submission
 // ---------------------------------------------------------------------------
 
 function handleAgentEvent(event: AgentEvent, state: AppState): void {
   switch (event.type) {
+    case "user_message":
+      state.messages.push(event.message);
+      state.contextTokens = addMessageToContextTokens(
+        state.contextTokens,
+        event.message,
+      );
+      break;
     case "assistant_message":
       state.messages.push(event.message);
       state.stats = addMessageToStats(state.stats, event.message);
@@ -270,12 +321,7 @@ export async function submitResolvedInput(
   }
 
   const session = ensureSession(state);
-  appendPromptHistory(state.db, {
-    text: rawInput,
-    cwd: state.cwd,
-    sessionId: session.id,
-  });
-  truncatePromptHistory(state.db, MAX_PROMPT_HISTORY);
+  recordRawPromptHistory(rawInput, state, session.id);
 
   const userMessage = {
     role: "user",
@@ -318,6 +364,7 @@ export async function submitResolvedInput(
       apiKey: state.providers.get(state.model.provider),
       effort: state.effort,
       signal: state.abortController.signal,
+      takeQueuedUserMessage: () => state.queuedUserMessages.shift() ?? null,
       onEvent: (event) => {
         handleAgentEvent(event, state);
         hooks?.onEvent?.(event, state);

package/src/tools.ts

@@ -490,9 +490,12 @@ interface ShellOpts {
   onUpdate?: ToolUpdateCallback;
 }
 
+type ShellProcess = ReturnType<typeof Bun.spawn>;
+
 const DEFAULT_MAX_LINES = 1000;
 const DEFAULT_MAX_BYTES = 50_000;
 const SHELL_UPDATE_INTERVAL_MS = 75;
+const SHELL_STREAM_DRAIN_TIMEOUT_MS = 25;
 
 /** Format combined stdout/stderr for display in tool results. */
 function formatShellOutput(stdout: string, stderr: string): string {
@@ -837,26 +840,132 @@ function normalizeShellCommand(command: string): string {
   }
 }
 
-/** Read a spawned shell stream into a string, reporting progressive updates. */
-async function consumeShellStream(
+interface ShellStreamCapture {
+  done: Promise<void>;
+  getOutput: () => string;
+  isFinished: () => boolean;
+  close: () => Promise<void>;
+}
+
+function startShellStreamCapture(
   stream: ReadableStream<Uint8Array>,
   onChunk: (chunk: string) => void,
-): Promise<string> {
+): ShellStreamCapture {
   const reader = stream.getReader();
   const decoder = new TextDecoder();
   let output = "";
+  let closed = false;
+  let finished = false;
+
+  const done = (async (): Promise<void> => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+
+        const chunk = decoder.decode(value, { stream: true });
+        output += chunk;
+        onChunk(chunk);
+      }
+    } catch (error) {
+      if (!closed) {
+        throw error;
+      }
+    } finally {
+      const trailing = decoder.decode();
+      output += trailing;
+      onChunk(trailing);
+      finished = true;
+    }
+  })();
 
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      output += decoder.decode();
-      return output;
+  return {
+    done,
+    getOutput: () => output,
+    isFinished: () => finished,
+    close: async (): Promise<void> => {
+      if (!finished) {
+        closed = true;
+        try {
+          await reader.cancel();
+        } catch {
+          // Ignore cancellation errors while closing the pipe after exit/abort.
+        }
+      }
+      await done;
+    },
+  };
+}
+
+async function finalizeShellStreamCaptures(
+  captures: readonly ShellStreamCapture[],
+): Promise<void> {
+  const pending = captures
+    .filter((capture) => !capture.isFinished())
+    .map((capture) => capture.done);
+
+  if (pending.length > 0) {
+    await new Promise<void>((resolve) => {
+      const timer = setTimeout(resolve, SHELL_STREAM_DRAIN_TIMEOUT_MS);
+      void Promise.allSettled(pending).then(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+
+  await Promise.all(captures.map((capture) => capture.close()));
+}
+
+function buildShellSpawnOptions(cwd: string): Parameters<typeof Bun.spawn>[1] {
+  return {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    ...(process.platform === "win32" ? {} : { detached: true }),
+  };
+}
+
+function abortShellProcess(proc: ShellProcess): void {
+  if (proc.killed || proc.exitCode !== null) {
+    return;
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-proc.pid, "SIGTERM");
+      return;
+    } catch {
+      // Fall through to a direct kill when the process group is unavailable.
     }
+  }
+
+  proc.kill("SIGTERM");
+}
+
+function registerShellAbort(
+  signal: AbortSignal | undefined,
+  proc: ShellProcess,
+): (() => void) | null {
+  if (!signal) {
+    return null;
+  }
+
+  const abortListener = (): void => {
+    abortShellProcess(proc);
+  };
 
-    const chunk = decoder.decode(value, { stream: true });
-    output += chunk;
-    onChunk(chunk);
+  if (signal.aborted) {
+    abortShellProcess(proc);
+    return null;
   }
+
+  signal.addEventListener("abort", abortListener, { once: true });
+  return () => {
+    signal.removeEventListener("abort", abortListener);
+  };
 }
 
 /**
@@ -880,22 +989,13 @@ export async function executeShell(
   const maxLines = opts?.maxLines ?? DEFAULT_MAX_LINES;
   const maxBytes = opts?.maxBytes ?? DEFAULT_MAX_BYTES;
   let updateTimer: ReturnType<typeof setTimeout> | null = null;
+  let cleanupAbort: (() => void) | null = null;
+  let lastReportedOutput = "";
+  let lastReportAt = 0;
+  let stdoutCapture: ShellStreamCapture | null = null;
+  let stderrCapture: ShellStreamCapture | null = null;
 
   try {
-    const spawnOpts: Parameters<typeof Bun.spawn>[1] = {
-      cwd,
-      stdout: "pipe",
-      stderr: "pipe",
-    };
-    if (opts?.signal) spawnOpts.signal = opts.signal;
-    const command = normalizeShellCommand(args.command);
-    const proc = Bun.spawn([shell, "-c", command], spawnOpts);
-
-    let stdoutBuf = "";
-    let stderrBuf = "";
-    let lastReportedOutput = "";
-    let lastReportAt = 0;
-
     const clearPendingUpdate = (): void => {
       if (updateTimer) {
         clearTimeout(updateTimer);
@@ -903,9 +1003,14 @@ export async function executeShell(
       }
     };
 
-    const buildProgressOutput = (): string => {
+    const buildOutput = (trimEnd: boolean): string => {
+      const stdout = stdoutCapture?.getOutput() ?? "";
+      const stderr = stderrCapture?.getOutput() ?? "";
       return truncateOutput(
-        formatShellOutput(stdoutBuf, stderrBuf),
+        formatShellOutput(
+          trimEnd ? stdout.trimEnd() : stdout,
+          trimEnd ? stderr.trimEnd() : stderr,
+        ),
         maxLines,
         maxBytes,
       );
@@ -917,7 +1022,7 @@ export async function executeShell(
         return;
       }
 
-      const output = buildProgressOutput();
+      const output = buildOutput(false);
       if (!output || output === lastReportedOutput) {
         return;
       }
@@ -946,24 +1051,29 @@ export async function executeShell(
       }, SHELL_UPDATE_INTERVAL_MS - elapsed);
     };
 
-    const [stdout, stderr, exitCode] = await Promise.all([
-      consumeShellStream(proc.stdout as ReadableStream<Uint8Array>, (chunk) => {
-        stdoutBuf += chunk;
+    const command = normalizeShellCommand(args.command);
+    const proc = Bun.spawn([shell, "-c", command], buildShellSpawnOptions(cwd));
+    cleanupAbort = registerShellAbort(opts?.signal, proc);
+    stdoutCapture = startShellStreamCapture(
+      proc.stdout as ReadableStream<Uint8Array>,
+      () => {
         scheduleUpdate();
-      }),
-      consumeShellStream(proc.stderr as ReadableStream<Uint8Array>, (chunk) => {
-        stderrBuf += chunk;
+      },
+    );
+    stderrCapture = startShellStreamCapture(
+      proc.stderr as ReadableStream<Uint8Array>,
+      () => {
         scheduleUpdate();
-      }),
-      proc.exited,
-    ]);
+      },
+    );
+
+    const exitCode = await proc.exited;
+    cleanupAbort?.();
+    cleanupAbort = null;
 
+    await finalizeShellStreamCaptures([stdoutCapture, stderrCapture]);
     clearPendingUpdate();
-    const output = truncateOutput(
-      formatShellOutput(stdout.trimEnd(), stderr.trimEnd()),
-      maxLines,
-      maxBytes,
-    );
+    const output = buildOutput(true);
     if (opts?.onUpdate && output && output !== lastReportedOutput) {
       lastReportedOutput = output;
       opts.onUpdate(textResult(output, false));
@@ -973,6 +1083,14 @@ export async function executeShell(
     const body = output || "(no output)";
     return textResult(`Exit code: ${exitCode}\n${body}`, isError);
   } catch (err) {
+    cleanupAbort?.();
+    cleanupAbort = null;
+    const captures = [stdoutCapture, stderrCapture].filter(
+      (capture): capture is ShellStreamCapture => capture !== null,
+    );
+    if (captures.length > 0) {
+      await Promise.allSettled(captures.map((capture) => capture.close()));
+    }
     if (updateTimer) {
       clearTimeout(updateTimer);
       updateTimer = null;

package/src/ui/agent.ts

@@ -13,7 +13,11 @@ import type { AssistantMessage } from "@mariozechner/pi-ai";
 import type { AgentEvent } from "../agent.ts";
 import { getErrorMessage } from "../errors.ts";
 import type { AppState } from "../index.ts";
-import { resolveRawInput, submitResolvedInput } from "../submit.ts";
+import {
+  queueResolvedInput,
+  resolveRawInput,
+  submitResolvedInput,
+} from "../submit.ts";
 import type {
   PendingToolResult,
   StreamingConversationState,
@@ -103,7 +107,12 @@ export function createUiAgentController(
         break;
     }
 
-    if (!state.model || state.running) {
+    if (state.running) {
+      queueResolvedInput(rawInput, resolved.content, state);
+      return;
+    }
+
+    if (!state.model) {
       return;
     }
 
@@ -154,6 +163,11 @@ export function createUiAgentController(
         runtime.render();
         break;
 
+      case "user_message":
+        runtime.scrollConversationToBottom();
+        runtime.render();
+        break;
+
       case "assistant_message":
         streamingContent = [];
         runtime.render();

package/src/ui/commands.test.ts

@@ -91,6 +91,7 @@ function createTestState(): AppState {
     running: false,
     abortController: null,
     activeTurnPromise: null,
+    queuedUserMessages: [],
     showReasoning: true,
     verbose: false,
     versionLabel: "dev",

package/src/ui/conversation.test.ts

@@ -838,6 +838,93 @@ describe("ui/conversation", () => {
     expect(text.some((line) => line.includes("TAIL"))).toBe(true);
   });
 
+  test("renderAssistantMessage for a long single-token shell argument wraps through the tail in a narrow viewport", async () => {
+    // Arrange
+    const command = `printf ${"x".repeat(40)}TAIL`;
+    const assistant = {
+      content: [fauxToolCall("shell", { command }, { id: "tool-1" })],
+    };
+
+    // Act
+    const text = await renderVisibleText(
+      renderAssistantMessage(assistant, {
+        ...RENDER_OPTS,
+        verbose: true,
+        previewWidth: 12,
+      }),
+      12,
+      20,
+    );
+
+    // Assert
+    expect(text.some((line) => line.includes("TAIL"))).toBe(true);
+  });
+
+  test("renderAssistantMessage for a long quoted shell string preserves string color across wrapped rows", async () => {
+    // Arrange
+    const command = `printf "${"x".repeat(80)}TAIL"`;
+    const assistant = {
+      content: [fauxToolCall("shell", { command }, { id: "tool-1" })],
+    };
+
+    // Act
+    const rows = await renderBufferRows(
+      renderAssistantMessage(assistant, {
+        ...RENDER_OPTS,
+        verbose: true,
+        previewWidth: 24,
+      }),
+      24,
+      20,
+    );
+    const headRowIndex = rows.findIndex((row) => row.text.includes('"x'));
+    const headRow = headRowIndex >= 0 ? rows[headRowIndex] : undefined;
+    const wrappedRow =
+      headRowIndex >= 0
+        ? rows
+            .slice(headRowIndex + 1)
+            .find((row) => row.text.includes("xxxxxxxx"))
+        : undefined;
+
+    // Assert
+    expect(headRow).toBeDefined();
+    expect(wrappedRow).toBeDefined();
+    expect(headRow?.fgColors[headRow.text.indexOf('"')]).toBe(
+      DEFAULT_THEME.diffAdded ?? null,
+    );
+    expect(wrappedRow?.fgColors[wrappedRow.text.indexOf("x")]).toBe(
+      DEFAULT_THEME.diffAdded ?? null,
+    );
+  });
+
+  test("renderAssistantMessage for long inline markdown code keeps the tail visible", async () => {
+    // Arrange
+    const message = fauxAssistantMessage(`Use \`${"x".repeat(80)}TAIL\``);
+
+    // Act
+    const rows = await renderBufferRows(
+      renderAssistantMessage(message, {
+        ...RENDER_OPTS,
+        previewWidth: 24,
+      }),
+      24,
+      20,
+    );
+    const codeRows = rows.filter(
+      (row) => row.text.includes("x") || row.text.includes("TAIL`"),
+    );
+
+    // Assert
+    expect(codeRows.length).toBeGreaterThan(1);
+    expect(rows.some((row) => row.text.includes("TAIL`"))).toBe(true);
+    expect(codeRows[0]?.fgColors[codeRows[0].text.indexOf("x")]).toBe(
+      DEFAULT_THEME.diffAdded ?? null,
+    );
+    expect(codeRows.at(-1)?.fgColors[codeRows.at(-1)!.text.indexOf("T")]).toBe(
+      DEFAULT_THEME.diffAdded ?? null,
+    );
+  });
+
   test("renderAssistantMessage for a long single-token shell command uses wrapped preview height when verbose is off", () => {
     // Arrange
     const command = `printf ${"x".repeat(220)}TAIL`;

package/src/ui/conversation.ts

@@ -34,6 +34,9 @@ const UI_TOOL_PREVIEW_ROWS = 8;
 /** Default width used when preview measurements do not receive one explicitly. */
 const DEFAULT_TOOL_PREVIEW_WIDTH = 80;
 
+/** Horizontal columns consumed by assistant-markdown padding. */
+const MARKDOWN_BLOCK_CHROME_WIDTH = 2;
+
 /** Horizontal columns consumed by tool-block padding and the left border. */
 const TOOL_BLOCK_CHROME_WIDTH = 4;
 
@@ -226,7 +229,11 @@ function renderUserMessage(msg: UserMessage, theme: Theme): Node {
 }
 
 /** Render a syntax-highlighted raw markdown block. */
-function renderMarkdownTextBlock(content: string, theme: Theme): Node | null {
+function renderMarkdownTextBlock(
+  content: string,
+  theme: Theme,
+  previewWidth?: number,
+): Node | null {
   if (content === "") {
     return null;
   }
@@ -238,6 +245,7 @@ function renderMarkdownTextBlock(content: string, theme: Theme): Node | null {
       themeVariant: "markdown",
     },
     theme,
+    getMarkdownBodyWidth(previewWidth),
   );
   if (children.length === 0) {
     return null;
@@ -313,7 +321,7 @@ function renderAssistantContentBlock(
   opts: ConversationRenderOpts,
 ): Node | null {
   if (block.type === "text" && block.text) {
-    return renderMarkdownTextBlock(block.text, opts.theme);
+    return renderMarkdownTextBlock(block.text, opts.theme, opts.previewWidth);
   }
   if (block.type === "thinking" && block.thinking) {
     return renderThinkingBlock(block.thinking, opts);
@@ -366,10 +374,21 @@ function getPreviewWidth(previewWidth?: number): number {
   return Math.max(1, Math.floor(previewWidth!));
 }
 
+function getMarkdownBodyWidth(previewWidth?: number): number {
+  return Math.max(
+    1,
+    getPreviewWidth(previewWidth) - MARKDOWN_BLOCK_CHROME_WIDTH,
+  );
+}
+
 function getToolBodyWidth(previewWidth?: number): number {
   return Math.max(1, getPreviewWidth(previewWidth) - TOOL_BLOCK_CHROME_WIDTH);
 }
 
+function getHighlightWrapChunkSize(bodyWidth: number): number {
+  return Math.max(1, Math.min(HIGHLIGHT_WRAP_MAX_CHUNK_GRAPHEMES, bodyWidth));
+}
+
 /** Split multi-line tool text into logical render lines. */
 function splitToolTextLines(
   text: string,
@@ -426,6 +445,7 @@ type SyntaxThemeTokenColor = NonNullable<
 const graphemeSegmenter = new Intl.Segmenter(undefined, {
   granularity: "grapheme",
 });
+const HIGHLIGHT_WRAP_MAX_CHUNK_GRAPHEMES = 32;
 const syntaxThemeCache: Record<
   SyntaxThemeVariant,
   WeakMap<Theme, SyntaxThemeRegistration>
@@ -559,6 +579,7 @@ function getSyntaxTheme(
 
 function splitHighlightedTextNode(
   node: Extract<Node, { type: "text" }>,
+  chunkSize: number,
 ): Node[] {
   if (node.content === "") {
     return [Text("", node.props)];
@@ -576,21 +597,37 @@ function splitHighlightedTextNode(
       continue;
     }
 
+    let chunk = "";
+    let chunkGraphemes = 0;
     for (const { segment } of graphemeSegmenter.segment(part)) {
-      children.push(Text(segment, node.props));
+      chunk += segment;
+      chunkGraphemes += 1;
+
+      if (chunkGraphemes === chunkSize) {
+        children.push(Text(chunk, node.props));
+        chunk = "";
+        chunkGraphemes = 0;
+      }
+    }
+
+    if (chunk !== "") {
+      children.push(Text(chunk, node.props));
     }
   }
 
   return children;
 }
 
-function normalizeHighlightedLine(line: Node): Node {
+function normalizeHighlightedLine(line: Node, bodyWidth: number): Node {
   if (line.type !== "hstack") {
     return line;
   }
 
+  const chunkSize = getHighlightWrapChunkSize(bodyWidth);
   const children = line.children.flatMap((child) => {
-    return child.type === "text" ? splitHighlightedTextNode(child) : [child];
+    return child.type === "text"
+      ? splitHighlightedTextNode(child, chunkSize)
+      : [child];
   });
   return HStack(line.props, children);
 }
@@ -598,6 +635,7 @@ function normalizeHighlightedLine(line: Node): Node {
 function getHighlightedBodyLines(
   spec: HighlightedBodySpec,
   theme: Theme,
+  bodyWidth: number,
 ): Node[] {
   if (spec.text === "") {
     return [];
@@ -606,7 +644,9 @@ function getHighlightedBodyLines(
   const highlighted = SyntaxHighlight(spec.text, spec.language, {
     theme: getSyntaxTheme(theme, spec.themeVariant),
   });
-  return highlighted.children.map((line) => normalizeHighlightedLine(line));
+  return highlighted.children.map((line) =>
+    normalizeHighlightedLine(line, bodyWidth),
+  );
 }
 
 /** Render a single styled text node for a tool line. */
@@ -740,7 +780,11 @@ function renderToolBody(
 ): { body: Node | null; summary?: ToolRenderLine } {
   if (spec.highlightedBody) {
     return renderToolBodyFromNodes(
-      getHighlightedBodyLines(spec.highlightedBody, opts.theme),
+      getHighlightedBodyLines(
+        spec.highlightedBody,
+        opts.theme,
+        getToolBodyWidth(opts.previewWidth),
+      ),
       spec.previewBody,
       opts,
     );

package/src/ui/input.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { DEFAULT_THEME } from "../theme.ts";
 import {
   autocompleteInputPath,
+  findInputPathMatches,
   type InputController,
   renderInputArea,
 } from "./input.ts";
@@ -60,7 +61,7 @@ describe("ui/input", () => {
     expect(placeholder.props.italic).toBe(true);
   });
 
-  test("autocompleteInputPath completes the last file path token", () => {
+  test("autocompleteInputPath completes the last file path token when exactly one match is available", () => {
     const cwd = createTempDir();
     mkdirSync(join(cwd, "src"), { recursive: true });
     writeFileSync(join(cwd, "src", "ui.ts"), "", "utf-8");
@@ -70,6 +71,33 @@ describe("ui/input", () => {
     );
   });
 
+  test("autocompleteInputPath returns null when multiple matches are available", () => {
+    const cwd = createTempDir();
+    mkdirSync(join(cwd, "src"), { recursive: true });
+    writeFileSync(join(cwd, "src", "ui.ts"), "", "utf-8");
+    writeFileSync(join(cwd, "src", "utils.ts"), "", "utf-8");
+
+    expect(autocompleteInputPath("inspect src/u", cwd)).toBeNull();
+  });
+
+  test("findInputPathMatches returns sorted selectable matches for the last file path token", () => {
+    const cwd = createTempDir();
+    mkdirSync(join(cwd, "src"), { recursive: true });
+    writeFileSync(join(cwd, "src", "alpine.ts"), "", "utf-8");
+    writeFileSync(join(cwd, "src", "alpha.ts"), "", "utf-8");
+
+    expect(findInputPathMatches("inspect src/al", cwd)).toEqual([
+      {
+        label: "src/alpha.ts",
+        value: "inspect src/alpha.ts",
+      },
+      {
+        label: "src/alpine.ts",
+        value: "inspect src/alpine.ts",
+      },
+    ]);
+  });
+
   test("autocompleteInputPath returns null when no completion is available", () => {
     const cwd = createTempDir();