mini-coder 0.6.2 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-coder",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "type": "module",
   "packageManager": "bun@1.3.12",
   "bin": {

package/src/agent.ts

@@ -9,6 +9,7 @@ import {
   type ToolResultMessage,
 } from "@earendil-works/pi-ai";
 import { getApiKey } from "./oauth";
+import { estimateTokens } from "./shared";
 import type {
   AgentContex,
   AgentEvent,
@@ -77,6 +78,10 @@ export async function* streamAgent(
 
   // Main agent loop, continues until llm sends a response other than toolCall or has no tool calls.
   while (true) {
+    let estimate = estimateTokens(JSON.stringify(llmCtx));
+    // 80k is the agreed uppon threshold to the DUMB ZONE
+    if (estimate > 80000) compactContext(llmCtx.messages);
+
     const s = streamSimple(agentCtx.options.model, llmCtx, {
       reasoning: agentCtx.options.effort,
       signal: agentCtx.signal,
@@ -103,13 +108,18 @@ export async function* streamAgent(
         case "thinking_end":
         case "toolcall_start":
         case "toolcall_delta":
-        case "toolcall_end":
+        case "toolcall_end": {
           if (partial) {
             partial = e.partial;
             llmCtx.messages[llmCtx.messages.length - 1] = partial;
             yield { type: "message_update", partial };
           }
+
+          estimate = estimateTokens(JSON.stringify(llmCtx));
+          // 80k is the agreed uppon threshold to the DUMB ZONE
+          if (estimate > 80000) compactContext(llmCtx.messages);
           break;
+        }
 
         case "error": {
           const finalMessage = await s.result();

package/src/git.ts

@@ -0,0 +1,23 @@
+import simpleGit from "simple-git";
+
+const git = simpleGit();
+
+export async function getGitStatus() {
+  try {
+    const status = await git.status();
+    return status;
+  } catch (_) {
+    return { nogit: "No git repo in this folder." };
+  } // No git
+}
+
+export async function getBranchLabel() {
+  try {
+    const status = await git.status();
+    const isClean = status.isClean();
+
+    return `${status.current}${isClean ? "" : "*"}`;
+  } catch (_) {
+    return "No git";
+  } // No git
+}

package/src/index.ts

@@ -1,6 +1,6 @@
 import { basename } from "node:path";
-import simpleGit from "simple-git";
 import { handleArgv } from "./args.ts";
+import { getBranchLabel } from "./git.ts";
 import { streamHeadless } from "./headless.ts";
 import { initTUI } from "./tui.ts";
 import type { TUIState } from "./types.ts";
@@ -23,18 +23,13 @@ export async function main(): Promise<void> {
     options,
     prompt: "",
     messages: [],
+    tuiMessages: [],
     streaming: false,
     stickToBottom: true,
     scrollOffset: 0,
     cwd,
+    gitBranch: await getBranchLabel(),
   };
 
-  const git = simpleGit();
-  try {
-    const gitStatus = (await git.status()).isClean() ? "" : "*";
-    const gitBranch = (await git.branch()).current;
-    state.gitBranch = `${gitBranch}${gitStatus}`;
-  } catch (_) {} // No git
-
   initTUI(state, leave);
 }

package/src/prompt.ts

@@ -3,7 +3,7 @@ import { readdir } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { join } from "node:path";
 import type { Message, ToolResultMessage } from "@earendil-works/pi-ai";
-import simpleGit, { type StatusResult } from "simple-git";
+import { getGitStatus } from "./git";
 import { parseSkillFrontmatter } from "./shared";
 
 export const MAIN_PROMPT = `You are a coding agent interacting with users via the mini-coder harness. You help users by reading files, executing commands, and editting code.
@@ -36,12 +36,7 @@ async function getDir() {
 
 async function getEnvPrompt() {
   // TODO: What else do the agents always check before answering every time?
-  let gitStatus: StatusResult | { nogit: string };
-  try {
-    gitStatus = await simpleGit().status();
-  } catch (_) {
-    gitStatus = { nogit: "No git repo in this folder." };
-  }
+  const gitStatus = await getGitStatus();
   const envKeys = ["PATH", "USER", "LANG", "HOME", "SHELL", "BUN_INSTALL"];
   const env: Record<string, string> = {};
   for (const key of envKeys) {
@@ -216,7 +211,7 @@ export function insertToolUsageReminder(
       for (const c of calls) {
         const args = JSON.stringify(c.arguments);
         if (seenArgs.has(args)) sameToolCount++;
-        seenArgs.add(args)
+        seenArgs.add(args);
       }
     }
   }

package/src/session.ts

@@ -5,8 +5,6 @@ import { Value } from "typebox/value";
 import { SESSIONS_DIR } from "./shared";
 import { type Session, SessionSchema } from "./types";
 
-// TODO: sessions are json files in SESSIONS_DIR inside of DATA_DIR, use a 10 length `secureRandomString()` for the ids.
-
 export async function ensureSessionsDir(): Promise<void> {
   await mkdir(SESSIONS_DIR, { recursive: true });
 }
@@ -71,8 +69,12 @@ export async function saveSession(s: Session) {
 export async function updateSession(id: string, messages: Message[]) {
   const existing = await getSession(id);
   if (existing) {
-    existing.messages = messages;
-    await saveSession(existing);
+    // Only append new messages, so we don't save compacted messages.
+    if (existing.messages.length < messages.length) {
+      const newMessages = messages.slice(existing.messages.length);
+      existing.messages = [...existing.messages, ...newMessages];
+      await saveSession(existing);
+    }
     return;
   }
 

package/src/tool-bash.ts

@@ -1,8 +1,6 @@
 import { type Tool, Type } from "@earendil-works/pi-ai";
-import { secureRandomString } from "./shared";
 import type { ToolRunnerEvent } from "./types";
 
-const OUTPUT_THRESHOLD = 16000;
 const description = `Bash CLI tool
 
 Execute shell commands on the user's environment.
@@ -68,25 +66,9 @@ export async function* runBashTool(
 
   const exitCode = await proc.exited;
 
-  let result = `# EXIT CODE: ${exitCode}`;
+  let result = `${output.length ? output : "(no ouput)"}\n\nExit code: ${exitCode}`;
   if (output.length) {
-    result += `
-# OUTPUT:
-
-${output}`;
-  }
-
-  // If `out` is too big, more than ~XXKB, write it to a temp file
-  // And add that to the truncation label for the agent to be able
-  // to continue the read with scans. This is to protect context,
-  // not a general read guard. The hint is for the agent, not the TUI
-  if (result.length > OUTPUT_THRESHOLD) {
-    const key = `${Date.now()}-${secureRandomString(4)}`;
-    const pathname = `/tmp/bash_result_${key}.txt`;
-    await Bun.write(pathname, result);
-    result = `${result.substring(0, OUTPUT_THRESHOLD)}
-
-Truncated at ~${OUTPUT_THRESHOLD / 1000}KB. Full output at ${pathname}`;
+    result += `${output}`;
   }
 
   yield {

package/src/tui-conversation.ts

@@ -8,220 +8,10 @@ import type {
 } 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.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.
@@ -159,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);
@@ -170,25 +176,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 +268,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 +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

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