mini-coder 0.6.2 → 0.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-coder",
-  "version": "0.6.2",
+  "version": "0.6.5",
   "type": "module",
   "packageManager": "bun@1.3.12",
   "bin": {
@@ -14,17 +14,17 @@
     "format": "bun run prettier --write *.md && bun run biome format --write . && bun run biome check --write ."
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.13",
-    "@types/bun": "^1.3.13",
+    "@biomejs/biome": "^2.4.15",
+    "@types/bun": "^1.3.14",
     "prettier": "^3.8.3",
     "typescript": "^6.0.3"
   },
   "dependencies": {
     "@cel-tui/components": "^0.8.3",
     "@cel-tui/core": "^0.8.3",
-    "@earendil-works/pi-ai": "^0.74.0",
+    "@earendil-works/pi-ai": "^0.75.5",
     "diff": "^9.0.0",
     "simple-git": "^3.36.0",
-    "yaml": "^2.8.3"
+    "yaml": "^2.9.0"
   }
 }

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/oauth.ts

@@ -5,11 +5,55 @@ import {
   getOAuthApiKey,
   getOAuthProvider,
   getOAuthProviders,
+  type OAuthLoginCallbacks,
+  type OAuthPrompt,
   type OAuthProviderId,
+  type OAuthSelectPrompt,
 } from "@earendil-works/pi-ai/oauth";
 import { AUTH_PATH as AUTH_FILE } from "./shared";
 import type { CliOptions, SavedOAuthCreds } from "./types";
 
+type ReadlineInterface = ReturnType<typeof readline.createInterface>;
+
+function ask(rl: ReadlineInterface, question: string): Promise<string> {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+function formatPrompt(prompt: OAuthPrompt): string {
+  const placeholder = prompt.placeholder ? ` (${prompt.placeholder})` : "";
+  return `${prompt.message}${placeholder}: `;
+}
+
+async function selectOption(
+  rl: ReadlineInterface,
+  prompt: OAuthSelectPrompt,
+): Promise<string | undefined> {
+  console.log(prompt.message);
+  for (let i = 0; i < prompt.options.length; i++) {
+    console.log(`${i + 1}. ${prompt.options[i]?.label}`);
+  }
+
+  const choice = await ask(rl, `Enter number (1-${prompt.options.length}): `);
+  const index = Number.parseInt(choice, 10) - 1;
+  return prompt.options[index]?.id;
+}
+
+function createLoginCallbacks(rl: ReadlineInterface): OAuthLoginCallbacks {
+  return {
+    onAuth: ({ url, instructions }) => {
+      console.log(`Open: ${url}`);
+      if (instructions) console.log(instructions);
+    },
+    onDeviceCode: ({ userCode, verificationUri }) => {
+      console.log(`Open: ${verificationUri}`);
+      console.log(`Enter code: ${userCode}`);
+    },
+    onPrompt: (prompt) => ask(rl, formatPrompt(prompt)),
+    onProgress: (message) => console.log(message),
+    onSelect: (prompt) => selectOption(rl, prompt),
+  };
+}
+
 export function isOAuthProvider(provider: string): boolean {
   return getOAuthProviders().some(
     (oauthProvider) => oauthProvider.id === provider,
@@ -47,18 +91,7 @@ export async function loginOAuth(provider: OAuthProviderId) {
   });
 
   try {
-    const creds = await oauthProvider.login({
-      onAuth: ({ url, instructions }) => {
-        console.log(`Open: ${url}`);
-        if (instructions) console.log(instructions);
-      },
-      onPrompt: async (prompt) => {
-        let answer: string = "";
-        await rl.question(prompt.message, (a) => (answer = a));
-        return answer;
-      },
-      onProgress: (message) => console.log(message),
-    });
+    const creds = await oauthProvider.login(createLoginCallbacks(rl));
 
     await writeCreds({ [provider]: { type: "oauth", ...creds } });
   } finally {

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-components.ts

@@ -88,7 +88,7 @@ export function Spinner() {
 }
 
 export function ActivityPill(state: TUIState, spinnerFrame: string) {
-  let label = "idle";
+  let label = "";
   const frame = state.streaming ? spinnerFrame : "";
 
   if (frame) {

package/src/tui-conversation.ts

@@ -1,227 +1,11 @@
 import { SyntaxHighlight } from "@cel-tui/components";
 import { HStack, type Node, Text, VStack } from "@cel-tui/core";
-import type {
-  AssistantMessage,
-  Message,
-  ToolResultMessage,
-  UserMessage,
-} from "@earendil-works/pi-ai";
-import { estimateTokens, relativeTime } from "./shared";
+import { estimateTokens } 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 +38,129 @@ 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" });
+  }
+
+  let argumentNodes: Node[] = [];
+
+  if (call.tool === "edit") {
+    argumentNodes = [
+      Text(`Writing... ~${estimateTokens(JSON.stringify(call.args))} tokens`),
+    ];
+  } else {
+    argumentNodes = 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 node;
+      }
+
+      return HStack({ gap: 1 }, [
+        Text(`${key}`, { italic: true, fgColor: theme.white }),
+        node,
+      ]);
+    });
+  }
+
+  return VStack({}, [
+    TextPill(call.tool, theme.black, theme.bwhite),
+    ...argumentNodes,
+    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: message.role === "user" ? 1 : 0 },
+        },
+        [SyntaxHighlight(message.text, "markdown")],
+      ),
+    );
+  }
+
+  if (message.toolCalls?.length) {
+    blocks.push(
+      VStack({ gap: 1 }, message.toolCalls.map(ConversationMessageToolCall)),
+    );
+  }
+
+  if (!message.thinking && !message.text.length && !message.toolCalls?.length) {
+    blocks.push(
+      Text(`Loading...`, {
+        wrap: "word",
+        fgColor: theme.bblack,
+      }),
+    );
+  }
+
+  // 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 +168,6 @@ export function Conversation(state: TUIState) {
         state.stickToBottom = offset >= maxOffset;
       },
     },
-    state.messages.map(conversationMessageNode),
+    state.tuiMessages.map(ConversationMessage),
   );
 }