mini-coder 0.5.6 → 0.5.8

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",
@@ -121,6 +122,7 @@ describe("ui/commands", () => {
         inputValue = value;
       },
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async () => {},
@@ -160,6 +162,7 @@ describe("ui/commands", () => {
         inputValue = value;
       },
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async () => {},
@@ -205,6 +208,7 @@ describe("ui/commands", () => {
         inputValue = value;
       },
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async () => {},
@@ -243,6 +247,7 @@ describe("ui/commands", () => {
       },
       setInputValue: () => {},
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async () => {},
@@ -309,6 +314,7 @@ describe("ui/commands", () => {
       },
       setInputValue: () => {},
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {
         scrollCalls += 1;
       },
@@ -392,6 +398,7 @@ describe("ui/commands", () => {
       dismissOverlay: () => {},
       setInputValue: () => {},
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async () => {},
@@ -414,6 +421,7 @@ describe("ui/commands", () => {
       dismissOverlay: () => {},
       setInputValue: () => {},
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async (nextState) => {
@@ -469,6 +477,7 @@ describe("ui/commands", () => {
       dismissOverlay: () => {},
       setInputValue: () => {},
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async () => {},
@@ -494,6 +503,7 @@ describe("ui/commands", () => {
       dismissOverlay: () => {},
       setInputValue: () => {},
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async () => {},
@@ -510,6 +520,66 @@ describe("ui/commands", () => {
     }
   });
 
+  test("/todo appends the current todo list without creating a session", () => {
+    const state = createTestState();
+    state.messages = [
+      {
+        role: "toolResult",
+        toolCallId: "todo-1",
+        toolName: "todoWrite",
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              todos: [
+                { content: "Review prompt wording", status: "completed" },
+                { content: "Implement todo tools", status: "in_progress" },
+              ],
+            }),
+          },
+        ],
+        isError: false,
+        timestamp: 1,
+      },
+    ];
+    const appended: Array<{
+      todos: Array<{ content: string; status: string }>;
+      sessionId: string | null;
+    }> = [];
+    const controller = createCommandController({
+      openOverlay: () => {},
+      dismissOverlay: () => {},
+      setInputValue: () => {},
+      appendInfoMessage: () => {},
+      appendTodoMessage: (todos, nextState) => {
+        appended.push({
+          todos: todos.map((todo) => ({ ...todo })),
+          sessionId: nextState.session?.id ?? null,
+        });
+      },
+      scrollConversationToBottom: () => {},
+      render: () => {},
+      reloadPromptContext: async () => {},
+      openInBrowser: () => {},
+    });
+
+    try {
+      expect(controller.handleCommand("todo", state)).toBe(true);
+      expect(appended).toEqual([
+        {
+          todos: [
+            { content: "Review prompt wording", status: "completed" },
+            { content: "Implement todo tools", status: "in_progress" },
+          ],
+          sessionId: null,
+        },
+      ]);
+      expect(state.session).toBeNull();
+    } finally {
+      state.db.close();
+    }
+  });
+
   test("applyModelSelection updates the state and persists the default model", () => {
     const faux = registerFauxProvider();
     const state = createTestState();
@@ -519,6 +589,7 @@ describe("ui/commands", () => {
       dismissOverlay: () => {},
       setInputValue: () => {},
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async () => {},
@@ -546,6 +617,7 @@ describe("ui/commands", () => {
       dismissOverlay: () => {},
       setInputValue: () => {},
       appendInfoMessage: () => {},
+      appendTodoMessage: () => {},
       scrollConversationToBottom: () => {},
       render: () => {},
       reloadPromptContext: async () => {},

package/src/ui/commands.ts

@@ -29,6 +29,7 @@ import {
   undoLastTurn,
 } from "../session.ts";
 import { updateSettings } from "../settings.ts";
+import { getTodoItems } from "../tools.ts";
 import { buildHelpText, COMMAND_DESCRIPTIONS } from "./help.ts";
 import { type ActiveOverlay, OVERLAY_MAX_VISIBLE } from "./overlay.ts";
 import { abbreviatePath } from "./status.ts";
@@ -51,6 +52,11 @@ interface UiCommandRuntime {
   setInputValue: (value: string) => void;
   /** Append a UI-only info message to the conversation log. */
   appendInfoMessage: (text: string, state: AppState) => void;
+  /** Append a UI-only todo snapshot to the conversation log. */
+  appendTodoMessage: (
+    todos: ReturnType<typeof getTodoItems>,
+    state: AppState,
+  ) => void;
   /** Re-enable stick-to-bottom behavior for the conversation log. */
   scrollConversationToBottom: () => void;
   /** Trigger a UI re-render. */
@@ -580,6 +586,10 @@ export function createCommandController(
     runtime.appendInfoMessage(buildHelpText(state), state);
   };
 
+  const handleTodoCommand = (state: AppState): void => {
+    runtime.appendTodoMessage(getTodoItems(state.messages), state);
+  };
+
   const handleCommand = (command: string, state: AppState): boolean => {
     switch (command) {
       case "model":
@@ -622,6 +632,9 @@ export function createCommandController(
       case "verbose":
         handleVerboseCommand(state);
         return true;
+      case "todo":
+        handleTodoCommand(state);
+        return true;
       case "help":
         handleHelpCommand(state);
         return true;

package/src/ui/conversation.test.ts

@@ -1057,6 +1057,33 @@ describe("ui/conversation", () => {
     expect(text).not.toContain("{");
   });
 
+  test("renderAssistantMessage for a todoWrite tool call shows a todo-count summary instead of raw JSON", () => {
+    // Arrange
+    const assistant = {
+      content: [
+        fauxToolCall(
+          "todoWrite",
+          {
+            todos: [
+              { content: "Inspect headless JSON output", status: "completed" },
+              { content: "Update the TUI preview", status: "in_progress" },
+            ],
+          },
+          { id: "tool-1" },
+        ),
+      ],
+    };
+
+    // Act
+    const text = collectText(renderAssistantMessage(assistant, RENDER_OPTS));
+
+    // Assert
+    expect(text).toContain("todo write ->");
+    expect(text).toContain("Updating todos... 2 todos updated");
+    expect(text).not.toContain("{");
+    expect(text).not.toContain('"todos"');
+  });
+
   test("renderAssistantMessage for an edit tool call shows both old and new content without diff prefixes", () => {
     // Arrange
     const assistant = {
@@ -1321,6 +1348,70 @@ describe("ui/conversation", () => {
     expect(text).not.toContain("error 17");
   });
 
+  test("renderToolResult for todoWrite shows the full checklist even when verbose is off", async () => {
+    const snapshot = JSON.stringify({
+      todos: [
+        { content: "Review prompt wording", status: "completed" },
+        { content: "Implement todo tools", status: "in_progress" },
+        { content: "Add /todo command", status: "pending" },
+        { content: "Run the full verification suite", status: "pending" },
+      ],
+    });
+
+    const text = await renderVisibleText(
+      renderToolResult("todoWrite", {}, snapshot, false, RENDER_OPTS),
+      PREVIEW_WIDTH,
+      24,
+    );
+
+    expect(text).toContain("todo write <-");
+    expect(text).toContain("[x] Review prompt wording");
+    expect(text).toContain("[~] Implement todo tools");
+    expect(text).toContain("[ ] Add /todo command");
+    expect(text.join(" ")).toContain("[ ] Run the full verification suite");
+    expect(text.some((line) => line.startsWith("And "))).toBe(false);
+  });
+
+  test("buildConversationLogNodes renders UI todo messages with the shared checklist block", async () => {
+    const state = {
+      messages: [
+        {
+          role: "ui" as const,
+          kind: "todo" as const,
+          todos: [
+            { content: "Review prompt wording", status: "completed" as const },
+            { content: "Implement todo tools", status: "in_progress" as const },
+            { content: "Add /todo command", status: "pending" as const },
+          ],
+          timestamp: 1,
+        },
+      ],
+      showReasoning: false,
+      verbose: false,
+      theme: DEFAULT_THEME,
+    };
+
+    const text = await renderVisibleText(
+      VStack(
+        {},
+        buildConversationLogNodes(
+          state,
+          { isStreaming: false, content: [], pendingToolResults: [] },
+          0,
+          PREVIEW_WIDTH,
+        ),
+      ),
+      PREVIEW_WIDTH,
+      24,
+    );
+
+    expect(text).toContain("todo");
+    expect(text).toContain("[x] Review prompt wording");
+    expect(text).toContain("[~] Implement todo tools");
+    expect(text).toContain("[ ] Add /todo command");
+    expect(text.some((line) => line.includes('"todos"'))).toBe(false);
+  });
+
   test("renderToolResult for a generic plugin tool uses the shared result header", () => {
     // Arrange
     const args = { query: "session persistence sqlite turn numbering" };

package/src/ui/conversation.ts

@@ -23,6 +23,7 @@ import type {
 import type { AppState } from "../index.ts";
 import type { UiMessage } from "../session.ts";
 import type { Theme } from "../theme.ts";
+import { parseTodoSnapshot, type TodoItem } from "../tools.ts";
 import { APP_NAME, DEV_VERSION_LABEL } from "../version.ts";
 
 /** Single blank-line gap used between conversation-level blocks. */
@@ -164,6 +165,8 @@ interface ToolBlockSpec {
   bodyLines: readonly ToolRenderLine[];
   /** Optional syntax-highlighted body rendered from the full unsplit source. */
   highlightedBody?: HighlightedBodySpec;
+  /** Optional custom body node rendered as-is. */
+  bodyNode?: Node;
   /** Whether `/verbose` preview rules apply to the body. */
   previewBody: boolean;
 }
@@ -412,6 +415,12 @@ function getToolArgString(args: Record<string, unknown>, key: string): string {
   return typeof value === "string" ? value : "";
 }
 
+function formatTodoWriteCallSummary(args: Record<string, unknown>): string {
+  const todoCount = Array.isArray(args.todos) ? args.todos.length : 0;
+  const todoLabel = todoCount === 1 ? "todo" : "todos";
+  return `Updating todos... ${todoCount} ${todoLabel} updated`;
+}
+
 /** Strip shell execution labels and normalize the exit line for the UI. */
 function normalizeShellOutput(output: string): string {
   return output
@@ -421,17 +430,18 @@ function normalizeShellOutput(output: string): string {
 }
 
 function getToolHeaderName(toolName: string): string {
-  return toolName === "readImage" ? "read image" : toolName;
+  return toolName.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
 }
 
 function getToolHeaderColor(toolName: string, theme: Theme) {
   switch (toolName) {
     case "shell":
+    case "readImage":
+    case "todoWrite":
+    case "todoRead":
       return theme.accentText;
     case "edit":
       return theme.secondaryAccentText;
-    case "readImage":
-      return theme.accentText;
     default:
       return theme.secondaryAccentText ?? theme.toolText;
   }
@@ -684,6 +694,48 @@ function renderToolLines(
   return lines.map((line) => renderToolLine(line, theme));
 }
 
+function getTodoMarker(todo: TodoItem): "[ ]" | "[~]" | "[x]" {
+  switch (todo.status) {
+    case "in_progress":
+      return "[~]";
+    case "completed":
+      return "[x]";
+    default:
+      return "[ ]";
+  }
+}
+
+function getTodoColor(todo: TodoItem, theme: Theme): Theme["toolText"] {
+  switch (todo.status) {
+    case "in_progress":
+      return theme.accentText;
+    case "completed":
+      return theme.diffAdded;
+    default:
+      return theme.toolText;
+  }
+}
+
+function renderTodoChecklist(todos: readonly TodoItem[], theme: Theme): Node {
+  if (todos.length === 0) {
+    return Text("No todo items.", {
+      fgColor: theme.mutedText,
+      italic: true,
+      wrap: "word",
+    });
+  }
+
+  return VStack(
+    {},
+    todos.map((todo) =>
+      Text(`${getTodoMarker(todo)} ${todo.content}`, {
+        fgColor: getTodoColor(todo, theme),
+        wrap: "word",
+      }),
+    ),
+  );
+}
+
 function measureToolNodesHeight(lines: readonly Node[], width: number): number {
   if (lines.length === 0) {
     return 0;
@@ -778,6 +830,10 @@ function renderToolBody(
   spec: ToolBlockSpec,
   opts: Pick<ConversationRenderOpts, "previewWidth" | "theme" | "verbose">,
 ): { body: Node | null; summary?: ToolRenderLine } {
+  if (spec.bodyNode) {
+    return { body: spec.bodyNode };
+  }
+
   if (spec.highlightedBody) {
     return renderToolBodyFromNodes(
       getHighlightedBodyLines(
@@ -868,6 +924,17 @@ function buildEditToolCallSpec(args: Record<string, unknown>): ToolBlockSpec {
   };
 }
 
+function buildTodoWriteToolCallSpec(
+  args: Record<string, unknown>,
+): ToolBlockSpec {
+  return {
+    toolName: "todoWrite",
+    direction: "->",
+    bodyLines: [{ kind: "text", text: formatTodoWriteCallSummary(args) }],
+    previewBody: false,
+  };
+}
+
 function buildReadImageToolCallSpec(
   args: Record<string, unknown>,
 ): ToolBlockSpec {
@@ -903,6 +970,9 @@ function buildToolCallSpec(
   if (toolName === "edit") {
     return buildEditToolCallSpec(args);
   }
+  if (toolName === "todoWrite") {
+    return buildTodoWriteToolCallSpec(args);
+  }
   if (toolName === "readImage") {
     return buildReadImageToolCallSpec(args);
   }
@@ -956,6 +1026,31 @@ function buildEditToolResultSpec(
   };
 }
 
+function buildTodoToolResultSpec(
+  toolName: string,
+  content: ToolResultMessage["content"],
+  isError: boolean,
+  theme: Theme,
+): ToolBlockSpec {
+  if (isError) {
+    return {
+      toolName,
+      direction: "<-",
+      bodyLines: splitToolTextLines(getToolContentText(content), "error"),
+      previewBody: false,
+    };
+  }
+
+  const todos = parseTodoSnapshot(getToolContentText(content)) ?? [];
+  return {
+    toolName,
+    direction: "<-",
+    bodyLines: [],
+    bodyNode: renderTodoChecklist(todos, theme),
+    previewBody: false,
+  };
+}
+
 function buildReadImageToolResultSpec(
   args: Record<string, unknown>,
   content: ToolResultMessage["content"],
@@ -1008,6 +1103,12 @@ function renderToolResultContent(
       opts,
     );
   }
+  if (toolName === "todoWrite" || toolName === "todoRead") {
+    return renderToolBlock(
+      buildTodoToolResultSpec(toolName, content, isError, opts.theme),
+      opts,
+    );
+  }
   if (toolName === "readImage") {
     return renderToolBlock(
       buildReadImageToolResultSpec(args, content, isError),
@@ -1045,8 +1146,26 @@ export function renderToolResult(
   return renderToolResultContent(toolName, args, content, isError, opts);
 }
 
+function renderUiTodoMessage(
+  msg: Extract<UiMessage, { kind: "todo" }>,
+  theme: Theme,
+): Node {
+  return VStack({ padding: { x: 1 } }, [
+    Text("todo", {
+      fgColor: theme.secondaryAccentText ?? theme.toolText,
+      bold: true,
+      wrap: "word",
+    }),
+    renderTodoChecklist(msg.todos, theme),
+  ]);
+}
+
 /** Render an internal UI message in the conversation log. */
 function renderUiMessage(msg: UiMessage, theme: Theme): Node {
+  if (msg.kind === "todo") {
+    return renderUiTodoMessage(msg, theme);
+  }
+
   return VStack({ padding: { x: 1 } }, [
     Text(msg.content, {
       fgColor: theme.mutedText,

package/src/ui/help.test.ts

@@ -22,6 +22,7 @@ describe("ui/help", () => {
     expect(text).toContain(
       "/verbose  Toggle verbose tool rendering (currently off)",
     );
+    expect(text).toContain("/todo  Show the current todo list");
   });
 
   test("buildHelpText describes the current Escape behavior", () => {

package/src/ui/help.ts

@@ -36,6 +36,7 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   undo: "Undo last turn",
   reasoning: "Toggle thinking display",
   verbose: "Toggle verbose tool rendering",
+  todo: "Show the current todo list",
   login: "OAuth login",
   logout: "OAuth logout",
   help: "Show help",

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();