mini-coder 0.6.2 → 0.6.5

package/src/tui-overlay.ts

@@ -1,10 +1,14 @@
 import { HStack, Text, TextInput, VStack } from "@cel-tui/core";
-import { getModels, type ThinkingLevel } from "@earendil-works/pi-ai";
+import {
+  getModels,
+  type Message,
+  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";
-import { estimateTokens } from "./shared";
+import { estimateTokens, formatTimestamp } from "./shared";
 import { TextPill, theme } from "./tui-components";
 import type { SelectOptions, SelectState, Session, TUIState } from "./types";
 
@@ -302,6 +306,61 @@ export function mainMenu(state: TUIState) {
     state.overlay = false;
   };
 
+  const toTUIMessage = (msg: Message) => {
+    const textFromContent = (
+      content: string | { type: string; text?: string }[],
+    ) =>
+      typeof content === "string"
+        ? content
+        : content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text ?? "")
+            .join("")
+            .trim();
+
+    if (msg.role === "user") {
+      return {
+        timestamp: formatTimestamp(msg.timestamp),
+        role: "user" as const,
+        text: textFromContent(msg.content)
+          .replaceAll(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "")
+          .trim(),
+      };
+    } else {
+      const text = msg.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("")
+        .trim();
+      const thinking = msg.content
+        .filter((c) => c.type === "thinking")
+        .map((c) => c.thinking)
+        .join("")
+        .trim();
+      const toolCalls = msg.content
+        .filter((c) => c.type === "toolCall")
+        .map((c) => {
+          const toolResult = state.messages.find(
+            (m) => m.role === "toolResult" && m.toolCallId === c.id,
+          );
+          return {
+            id: c.id,
+            tool: c.name,
+            args: c.arguments,
+            output: toolResult ? textFromContent(toolResult.content) : "",
+          };
+        });
+
+      return {
+        timestamp: formatTimestamp(msg.timestamp),
+        role: "assistant" as const,
+        text,
+        thinking,
+        toolCalls,
+      };
+    }
+  };
+
   const select = useSelectOverlay({
     ...mainPane,
     onSelect: (s) => {
@@ -331,6 +390,9 @@ export function mainMenu(state: TUIState) {
 
         state.sessionId = session.id;
         state.messages = session.messages;
+        state.tuiMessages = session.messages
+          .filter((message) => message.role !== "toolResult")
+          .map(toTUIMessage);
         state.prompt = "";
         state.contextSize = estimateTokens(JSON.stringify(state.messages));
         state.scrollOffset = 0;

package/src/tui.ts

@@ -1,6 +1,10 @@
 import { cel, HStack, ProcessTerminal, VStack } from "@cel-tui/core";
-import simpleGit from "simple-git";
-import { compactContext, streamAgent } from "./agent";
+import type {
+  AssistantMessage,
+  ToolResultMessage,
+} from "@earendil-works/pi-ai";
+import { streamAgent } from "./agent";
+import { getBranchLabel } from "./git";
 import {
   buildSystemPrompt,
   injectEnvReminder,
@@ -8,7 +12,7 @@ import {
   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";
@@ -24,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.
@@ -88,6 +89,7 @@ export function initTUI(state: TUIState, leave: (s: string) => void) {
       if (state.prompt === ":n" || state.prompt === "/new") {
         state.sessionId = undefined;
         state.messages = [];
+        state.tuiMessages = [];
         state.prompt = "";
         state.contextSize = 0;
         state.scrollOffset = 0;
@@ -159,6 +161,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);
@@ -170,25 +177,84 @@ 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": {
+          updateToolCall(ev.message, state.tuiMessages);
           const withReminder = insertToolUsageReminder(
             state.messages,
             ev.message,
@@ -203,7 +269,10 @@ async function streamAgentTUI(state: TUIState) {
             state.messages[idx] = withReminder;
           }
 
-          state.contextSize = estimateTokens(JSON.stringify(ctx));
+          const { systemPrompt, tools, messages } = ctx;
+          state.contextSize = estimateTokens(
+            JSON.stringify({ systemPrompt, tools, messages }),
+          );
         }
       }
     }
@@ -213,20 +282,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

@@ -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;