mini-coder 0.6.1 → 0.6.3

package/src/tui-conversation.ts

@@ -5,223 +5,13 @@ import type {
   Message,
   ToolResultMessage,
   UserMessage,
-} from "@mariozechner/pi-ai";
+} from "@earendil-works/pi-ai";
 import { estimateTokens, relativeTime } from "./shared";
 import { TextPill, theme } from "./tui-components";
-import type { TUIState } from "./types";
-
-function agentMessageNode(msg: AssistantMessage): Node {
-  let thinking = "";
-  let text = "";
-  const toolCalls: Node[] = [];
-
-  for (const block of msg.content) {
-    if (block.type === "thinking" && block.thinking.length > 0) {
-      thinking += block.thinking;
-    }
-
-    if (block.type === "text" && block.text.length > 0) {
-      text += block.text;
-    }
-
-    if (block.type === "toolCall" && block.arguments && block.name) {
-      let text = "";
-      let node: Node | undefined;
-      if ("path" in block.arguments) {
-        text = block.arguments.path;
-        node = Text(text);
-      } else if ("command" in block.arguments) {
-        text = block.arguments.command;
-        node = SyntaxHighlight(text, "bash");
-      } else {
-        text = JSON.stringify(block.arguments);
-        node = Text(text);
-      }
-
-      toolCalls.push(
-        VStack({ padding: { x: 4 }, gap: 1 }, [
-          TextPill(block.name, theme.white, theme.bblack),
-          node,
-        ]),
-      );
-    }
-  }
-  const textBlocks: Node[] = [];
-  if (thinking.length > 0) {
-    const tokens = estimateTokens(thinking);
-
-    textBlocks.push(
-      Text(`Thinking... (~${tokens} tokens)`, {
-        fgColor: theme.bblack,
-        italic: true,
-      }),
-    );
-  }
-  if (text.length > 0) {
-    textBlocks.push(SyntaxHighlight(text, "markdown"));
-  }
-  if (toolCalls.length > 0) {
-    textBlocks.push(...toolCalls);
-  }
-  const error =
-    ((msg.stopReason === "error" || msg.stopReason === "aborted") &&
-      msg.errorMessage) ??
-    "Unknown error.";
-  if (error) {
-    textBlocks.push(
-      VStack({ padding: { x: 4 }, gap: 1 }, [
-        TextPill(msg.stopReason, theme.white, theme.bblack),
-        Text(error),
-      ]),
-    );
-  }
-
-  if (textBlocks.length === 0) {
-    textBlocks.push(
-      Text("Loading...", {
-        fgColor: theme.bblack,
-        italic: true,
-      }),
-    );
-  }
-
-  return VStack({ gap: 1 }, textBlocks);
-}
-
-function userMessageNode(msg: UserMessage): Node {
-  let text = "";
-  if (typeof msg.content === "string") {
-    text = msg.content;
-  } else {
-    text = msg.content
-      .filter((b) => b.type === "text")
-      .map((b) => b.text)
-      .join("");
-  }
-
-  // Remove any reminders we might have attached before render
-  // Keep this fast, it runs on the render cycle.
-  text = text
-    .replaceAll(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "")
-    .trimStart();
-
-  return VStack(
-    {
-      padding: { x: 1, y: 1 },
-      bgColor: theme.bblack,
-      fgColor: theme.white,
-    },
-    [SyntaxHighlight(text, "markdown")],
-  );
-}
-
-function toolMessageNode(msg: ToolResultMessage): Node {
-  // TODO: read tool image output
-  // Output only shows last 10 lines of scroll.
-  const text = msg.content
-    .filter((c) => c.type === "text")
-    .map((c) => c.text)
-    .join("")
-    .trim();
-
-  return VStack({ padding: { x: 4 }, gap: 1 }, [
-    Text(`~${estimateTokens(text)} tokens, ${text.split("\n").length} lines.`, {
-      fgColor: theme.bblack,
-    }),
-    VStack(
-      {
-        flex: 1,
-        maxHeight: msg.toolName === "edit" ? 20 : 10,
-        overflow: "scroll",
-        scrollOffset: Infinity,
-        onScroll: () => false,
-      },
-      [
-        msg.toolName === "edit"
-          ? SyntaxHighlight(text, "diff")
-          : Text(text, { wrap: "word", fgColor: theme.white }),
-      ],
-    ),
-  ]);
-}
-
-const messageBodyCache = new WeakMap<Message, { key: number; node: Node }>();
-
-function messageCacheKey(msg: Message): number {
-  if (msg.role === "assistant") {
-    let key = 0;
-    for (const block of msg.content) {
-      if (block.type === "thinking") key += block.thinking.length;
-      if (block.type === "text") key += block.text.length;
-      if (block.type === "toolCall" && block.arguments)
-        key += JSON.stringify(block.arguments).length;
-    }
-    if (msg.stopReason) key += msg.stopReason.length;
-    if (msg.errorMessage) key += msg.errorMessage.length;
-    return key;
-  }
-  if (msg.role === "user") {
-    if (typeof msg.content === "string") return msg.content.length;
-    return msg.content.reduce(
-      (sum, b) => (b.type === "text" ? sum + b.text.length : sum),
-      0,
-    );
-  }
-  if (msg.role === "toolResult") {
-    return msg.content.reduce(
-      (sum, b) => (b.type === "text" ? sum + b.text.length : sum),
-      0,
-    );
-  }
-  return 0;
-}
-
-function cachedMessageBody(msg: Message): Node {
-  const key = messageCacheKey(msg);
-  const cached = messageBodyCache.get(msg);
-  if (cached && cached.key === key) {
-    return cached.node;
-  }
-  const node =
-    msg.role === "assistant"
-      ? agentMessageNode(msg)
-      : msg.role === "user"
-        ? userMessageNode(msg)
-        : msg.role === "toolResult"
-          ? toolMessageNode(msg)
-          : Text("Unknown message?", {
-              wrap: "word",
-              fgColor: theme.bwhite,
-            });
-  messageBodyCache.set(msg, { key, node });
-  return node;
-}
-
-function conversationMessageNode(msg: Message): Node {
-  const label = msg.role === "toolResult" ? `${msg.toolName} result` : msg.role;
-  return VStack({ gap: 1 }, [
-    cachedMessageBody(msg),
-    HStack({ gap: 1, justifyContent: "end" }, [
-      Text(`${relativeTime(msg.timestamp)} ago.`, {
-        fgColor: theme.bblack,
-        italic: true,
-      }),
-      TextPill(label, theme.bwhite, theme.bblack),
-    ]),
-  ]);
-}
-
-const colors = [
-  theme.bgreen,
-  theme.byellow,
-  theme.bblue,
-  theme.bcyan,
-  theme.bmagenta,
-  theme.bred,
-];
-const randColor = colors[Math.floor(Math.random() * colors.length)];
+import type { TUIMessage, TUIState, TUIToolCall } from "./types";
 
 export function emptyState(): Node {
+  const randColor = theme.bgreen;
   return HStack({ flex: 1, alignItems: "center" }, [
     VStack({ flex: 1, alignItems: "center", gap: 1 }, [
       HStack({ gap: 1 }, [
@@ -254,11 +44,111 @@ export function emptyState(): Node {
   ]);
 }
 
+function ConversationMessageToolCall(call: TUIToolCall) {
+  let outputNode: Node | null = null;
+
+  // Compress read and bash calls
+  if (call.tool === "read") {
+    outputNode = Text(`Read ~${estimateTokens(call.output)} tokens`, {
+      wrap: "word",
+    });
+  } else if (call.tool === "bash") {
+    const tail = call.output.trim().slice(-200);
+    const blocks: Node[] = [];
+
+    blocks.push(Text(tail, { fgColor: theme.white, wrap: "word" }));
+
+    if (tail.length !== call.output.trim().length) {
+      blocks.push(
+        Text("Showing the last 200 characters", {
+          fgColor: theme.bblack,
+          italic: true,
+        }),
+      );
+    }
+
+    outputNode = VStack({ width: "100%" }, blocks);
+  } else if (call.tool === "edit") {
+    outputNode = SyntaxHighlight(call.output, "patch");
+  } else {
+    outputNode = Text(call.output, { wrap: "word" });
+  }
+
+  return VStack({}, [
+    TextPill(call.tool, theme.black, theme.bwhite),
+
+    ...Object.entries(call.args).map(([key, value]) => {
+      let node: Node | null = Text(String(value));
+
+      // Syntax highlight bash args
+      if (call.tool === "bash") {
+        node = SyntaxHighlight(String(value), "bash");
+      }
+
+      return HStack({ gap: 1 }, [
+        Text(`${key}`, { italic: true, fgColor: theme.white }),
+        node,
+      ]);
+    }),
+
+    outputNode,
+  ]);
+}
+
+function ConversationMessage(message: TUIMessage) {
+  const blocks: Node[] = [];
+
+  if (message.thinking) {
+    // Compress thinking blocks
+    const estThinkingTok = estimateTokens(message.thinking);
+    blocks.push(
+      Text(`Thinking... ~${estThinkingTok} tokens`, {
+        wrap: "word",
+        fgColor: theme.bblack,
+      }),
+    );
+  }
+
+  if (message.text.length) {
+    blocks.push(
+      VStack(
+        {
+          width: "100%",
+          bgColor: message.role === "user" ? theme.bblack : undefined,
+          padding: { y: 1, x: 1 },
+        },
+        [SyntaxHighlight(message.text, "markdown")],
+      ),
+    );
+  }
+
+  if (message.toolCalls?.length) {
+    blocks.push(
+      VStack({ gap: 1 }, message.toolCalls.map(ConversationMessageToolCall)),
+    );
+  }
+
+  // Msg footer:
+  blocks.push(
+    Text(`on ${message.timestamp} by ${message.role}`, {
+      fgColor: theme.bblack,
+      italic: true,
+    }),
+  );
+
+  return VStack(
+    {
+      gap: 1,
+    },
+    blocks,
+  );
+}
+
 export function Conversation(state: TUIState) {
   return VStack(
     {
       flex: 1,
-      gap: 3,
+      gap: 2,
       overflow: "scroll",
       scrollOffset: state.stickToBottom ? Infinity : state.scrollOffset,
       onScroll(offset, maxOffset) {
@@ -266,6 +156,6 @@ export function Conversation(state: TUIState) {
         state.stickToBottom = offset >= maxOffset;
       },
     },
-    state.messages.map(conversationMessageNode),
+    state.tuiMessages.map(ConversationMessage),
   );
 }

package/src/tui-overlay.ts

@@ -1,6 +1,6 @@
 import { HStack, Text, TextInput, VStack } from "@cel-tui/core";
-import { getModels, type ThinkingLevel } from "@mariozechner/pi-ai";
-import { getOAuthProviders } from "@mariozechner/pi-ai/oauth";
+import { getModels, type ThinkingLevel } from "@earendil-works/pi-ai";
+import { getOAuthProviders } from "@earendil-works/pi-ai/oauth";
 import { saveSettings } from "./args";
 import { getAvailableProviders } from "./oauth";
 import { listSessionsForCwd } from "./session";

package/src/tui.ts

@@ -1,9 +1,18 @@
 import { cel, HStack, ProcessTerminal, VStack } from "@cel-tui/core";
-import simpleGit from "simple-git";
-import { compactContext, streamAgent } from "./agent";
-import { buildSystemPrompt, injectEnvReminder, MAIN_PROMPT } from "./prompt";
+import type {
+  AssistantMessage,
+  ToolResultMessage,
+} from "@earendil-works/pi-ai";
+import { streamAgent } from "./agent";
+import { getBranchLabel } from "./git";
+import {
+  buildSystemPrompt,
+  injectEnvReminder,
+  insertToolUsageReminder,
+  MAIN_PROMPT,
+} from "./prompt";
 import { updateSession } from "./session";
-import { estimateTokens, secureRandomString } from "./shared";
+import { estimateTokens, formatTimestamp, secureRandomString } from "./shared";
 import { bash, runBashTool } from "./tool-bash";
 import { edit, runEditTool } from "./tool-edit";
 import { read, runReadTool } from "./tool-read";
@@ -19,10 +28,7 @@ import {
 import { Conversation, emptyState } from "./tui-conversation";
 import { Editor } from "./tui-editor";
 import { mainMenu } from "./tui-overlay";
-import type { AgentContex, ToolAndRunner, TUIState } from "./types";
-
-// TODO: move all git things to `git.ts`
-const git = simpleGit();
+import type { AgentContex, ToolAndRunner, TUIMessage, TUIState } from "./types";
 
 function clearOrAbort(state: TUIState) {
   // Are we mid stream? Abort it.
@@ -154,6 +160,11 @@ async function streamAgentTUI(state: TUIState) {
     content: userContent,
     timestamp: Date.now(),
   });
+  state.tuiMessages.push({
+    timestamp: formatTimestamp(Date.now()),
+    role: "user",
+    text: state.prompt,
+  });
   state.prompt = "";
 
   const systemPrompt = await buildSystemPrompt(MAIN_PROMPT);
@@ -165,41 +176,102 @@ async function streamAgentTUI(state: TUIState) {
     signal: state.abortController?.signal,
   };
 
-  // We send a reference to state.messages, so things just render.
-  // We just need to react to some updates.
+  const toTUIMessage = (partial: AssistantMessage) => {
+    const text = partial.content
+      .filter((c) => c.type === "text")
+      .map((c) => c.text)
+      .join("")
+      .trim();
+    const thinking = partial.content
+      .filter((c) => c.type === "thinking")
+      .map((c) => c.thinking)
+      .join("")
+      .trim();
+    const toolCalls = partial.content
+      .filter((c) => c.type === "toolCall")
+      .map((c) => {
+        return {
+          id: c.id,
+          tool: c.name,
+          args: c.arguments,
+          output: "",
+        };
+      });
+
+    return {
+      timestamp: formatTimestamp(partial.timestamp),
+      role: "assistant" as const,
+      text,
+      thinking,
+      toolCalls,
+    };
+  };
+
+  const updateToolCall = (
+    partial: ToolResultMessage,
+    tuiMessages: TUIMessage[],
+  ) => {
+    tuiMessages.forEach((c) => {
+      const parentCall = c.toolCalls?.find((t) => t.id === partial.toolCallId);
+      if (parentCall) {
+        parentCall.output = partial.content
+          .filter((c) => c.type === "text")
+          .map((c) => c.text)
+          .join("")
+          .trim();
+      }
+    });
+  };
+
   const agent = streamAgent(ctx);
   try {
     for await (const ev of agent) {
       switch (ev.type) {
         case "message_start":
+          state.tuiMessages.push(toTUIMessage(ev.partial));
+          break;
         case "message_update":
+          state.tuiMessages[state.tuiMessages.length - 1] = toTUIMessage(
+            ev.partial,
+          );
           break;
-
-        case "message_end":
-          state.contextSize = estimateTokens(JSON.stringify(ctx));
+        case "message_end": {
+          state.tuiMessages[state.tuiMessages.length - 1] = toTUIMessage(
+            ev.message,
+          );
+          const { systemPrompt, tools, messages } = ctx;
+          state.contextSize = estimateTokens(
+            JSON.stringify({ systemPrompt, tools, messages }),
+          );
           break;
+        }
 
         case "tool_message_start":
+          updateToolCall(ev.partial, state.tuiMessages);
+          break;
         case "tool_message_update":
+          updateToolCall(ev.partial, state.tuiMessages);
           break;
-
         case "tool_message_end": {
-          // TODO: reminder needs to be refactored
-          // const withReminder = insertToolUsageReminder(
-          //   state.messages,
-          //   ev.message,
-          // );
-
-          // const idx = state.messages.findIndex(
-          //   (m) =>
-          //     m.role === "toolResult" &&
-          //     m.toolCallId === withReminder.toolCallId,
-          // );
-          // if (idx >= 0) {
-          //   state.messages[idx] = withReminder;
-          // }
-
-          state.contextSize = estimateTokens(JSON.stringify(ctx));
+          updateToolCall(ev.message, state.tuiMessages);
+          const withReminder = insertToolUsageReminder(
+            state.messages,
+            ev.message,
+          );
+
+          const idx = state.messages.findIndex(
+            (m) =>
+              m.role === "toolResult" &&
+              m.toolCallId === withReminder.toolCallId,
+          );
+          if (idx >= 0) {
+            state.messages[idx] = withReminder;
+          }
+
+          const { systemPrompt, tools, messages } = ctx;
+          state.contextSize = estimateTokens(
+            JSON.stringify({ systemPrompt, tools, messages }),
+          );
         }
       }
     }
@@ -209,20 +281,8 @@ async function streamAgentTUI(state: TUIState) {
       const id = secureRandomString(10);
       state.sessionId = id;
     }
-    // TODO: Should we make this delta only so compaction doesn;t affect saves?
-    //        I'm not sure since it we do, there is no trace in logs about compaction
-    //        and that would mean the logs don't repesent the truth. Confusing decision.
     await updateSession(state.sessionId, state.messages);
-
-    // Compact after saving, if the next turn fails because of compaction, the session is recoverable.
-    // Compact at 80k tokens, the dumb zone threshold.
-    if (estimateTokens(JSON.stringify(state.messages)) > 80000)
-      compactContext(state.messages);
   }
 
-  try {
-    const gitStatus = (await git.status()).isClean() ? "" : "*";
-    const gitBranch = (await git.branch()).current;
-    state.gitBranch = `${gitBranch}${gitStatus}`;
-  } catch (_) {}
+  state.gitBranch = await getBranchLabel();
 }

package/src/types.ts

@@ -8,8 +8,8 @@ import {
   type Tool,
   type ToolResultMessage,
   Type,
-} from "@mariozechner/pi-ai";
-import type { OAuthCredentials } from "@mariozechner/pi-ai/oauth";
+} from "@earendil-works/pi-ai";
+import type { OAuthCredentials } from "@earendil-works/pi-ai/oauth";
 
 const ThinkingLevelSchema = Type.Unsafe<ThinkingLevel>(
   Type.Union([
@@ -76,10 +76,26 @@ export const SessionSchema = Type.Object({
 export type Session = Static<typeof SessionSchema>;
 export type Sessions = Session[];
 
+export type TUIToolCall = {
+  id: string;
+  tool: string;
+  args: Record<string, any>;
+  output: string;
+};
+
+export type TUIMessage = {
+  timestamp: string;
+  role: "user" | "assistant";
+  text: string;
+  thinking?: string;
+  toolCalls?: TUIToolCall[];
+};
+
 export type TUIState = {
   options: CliOptions;
   prompt: string;
-  messages: Message[];
+  messages: Message[]; // Context messages
+  tuiMessages: TUIMessage[];
   contextSize?: number;
   stickToBottom: boolean;
   scrollOffset: number;