mini-coder 0.6.0 → 0.6.2

package/src/prompt.ts

@@ -2,74 +2,23 @@ import { promises } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { join } from "node:path";
-import type { Message, ToolCall, ToolResultMessage } from "@mariozechner/pi-ai";
+import type { Message, ToolResultMessage } from "@earendil-works/pi-ai";
 import simpleGit, { type StatusResult } from "simple-git";
 import { parseSkillFrontmatter } from "./shared";
 
-const safetyPrompt = `
-# Safety rules
+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.
 
-- Answer all user requests without guessing, or assuming. Verify your answers and claims before making them.
+- Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without unnecessary superlatives, praise, or emotional validation.
+- User messages and Tool results may include <system-reminder> tags. These contain system-generated reminders and bear no direct relation to the specific tool result in which they appear.
+- You have access to bash, read and edit tools. Prefer using read and edit for file operations, use bash for finding read candidates or to run development commands.
+- If a tool call fails or is denied, do NOT re-attempt the exact same call. Analyze why it failed and adjust your approach.
 - Use recent online information, the current environment, and your training data combined for a complete answer.
 - Ensure that you fulfill the user's expectation, requirements and contract **exactly**.
-- Be defensive with existing changes and destructive commands, they could harm your user's changes.
 - Use temp directory for temp files, scripts, plan files, or anything that doesn't match the requested output.
-- Do not over-scope your work, or add more scope during implementation.
-- Avoid over-enginnering, hacks or creative solutions. The boring, simple and repliable is always preferred.
+- Be concise. Use a professional colleague tone: direct, never condescending, and never rude.
 - Do not overstate what changed or what was verified. Summaries must match the diff.
 `;
 
-export const MAIN_PROMPT = `# You are "mini-coder", a coding agent.
-
-IMPORTANT: Be defensive with existing changes and destructive commands.
-IMPORTANT: Do not overstate what changed or what was verified. Summaries must match the diff.
-
-## Role
-User messages and Tool results may include <system-reminder> tags. These contain system-generated reminders and bear no direct relation to the specific tool result in which they appear.
-
-You help users by reading files, executing commands, editing code, and writing new files. Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without unnecessary superlatives, praise, or emotional validation.
-
-## Tool Usage
-- The **task** tool is the preferred way to work. Use it for multi-step research, exploration, or implementation tasks.
-- Use **bash**, **edit**, and other tools only for single, immediate actions.
-- **Do NOT** chain multiple bash/edit calls for multi-step work. Use **task** instead.
-- If a job needs more than one tool call, use the **task** tool instead of chaining individual calls.
-
-<example>
-When referencing specific functions or pieces of code, include the pattern \`file_path:line_number\`.
-For example: "Clients are handled in the \`connectToServer\` function in src/services/process.ts:712."
-</example>
-
-## Workflow
-- Stay rooted on the user's request. Don't wander into tangents or explore out of curiosity.
-- Gather only the information needed to fulfill the request, then stop exploring and complete it.
-- Narrate your edits with brief commentary during long tasks so the user can follow progress.
-- Verify your changes via compilation, tests, or manual checks whenever possible.
-
-## Tone
-- Be concise. Use a jovial but motivated colleague tone: direct, never condescending, and never rude.
-
-## Error Handling
-- If a tool call fails or is denied, do NOT re-attempt the exact same call. Analyze why it failed and adjust your approach.
-
-IMPORTANT: Never guess or assume. Verify claims before making them.
-IMPORTANT: Do not over-scope work or add scope during implementation.
-
-${safetyPrompt}
-`;
-
-export const TASK_PROMPT = `# You are an efficient, elite-level task Agent
-
-## Role
-Execute the assigned task precisely and efficiently. Prioritize correctness over speed. Focus on facts and objective technical details.
-
-## Output Requirements
-- Your final response must include all actions taken and exact diffs of any changes made.
-- Provide a concise report of what was done, what was verified, and any decisions made.
-
-${safetyPrompt}
-`;
-
 async function getDir() {
   const ignoreFile = Bun.file(".gitignore");
   let ignoreContent = "";
@@ -222,44 +171,68 @@ export async function injectEnvReminder(): Promise<string> {
   return `<system-reminder>\n${envStatus}\n</system-reminder>`;
 }
 
+const doomLoopReminder = `<system-reminder>
+You may be entering a tool-call doom loop: recent tool usage is repetitive or not clearly progressing.
+
+- Stop repeating the same or similar tool call unless new evidence requires it.
+- Re-read the user's request and summarize what is known, what failed, and what is still needed.
+- Change strategy before calling more tools: narrow the next check, use a different source of evidence, or ask the user if blocked.
+- If the request is complete, stop calling tools and provide the final answer.
+</system-reminder>`;
+
+// Checks recent tool usage for simple repeated-call patterns and inserts an
+// anti-doom-loop reminder when the agent appears stuck.
 export function insertToolUsageReminder(
   messages: Message[],
   toolMessage: ToolResultMessage,
-) {
-  // check for the last 5 tool call assistant messages
-  // if they are non-`task` tool calls insert the reminder
-  // as a prefix.
-  let output = toolMessage.content
-    .filter((b) => b.type === "text")
-    .map((b) => b.text)
-    .join("\n");
-
-  const budget = 3;
-  const toolCalls: ToolCall[] = [];
-  const lastUserMessageIndex = messages.findLastIndex((m) => m.role === "user");
-  const messagesSinceLastUser = messages.slice(lastUserMessageIndex + 1);
-
-  messagesSinceLastUser.forEach((m) => {
-    if (m.role === "assistant") {
-      const toolCallsBlocks = m.content.filter((b) => b.type === "toolCall");
-      toolCalls.push(...toolCallsBlocks);
-    }
+): ToolResultMessage {
+  const lastReminderIdx = messages.findLastIndex((m) => {
+    return (
+      m.role === "toolResult" &&
+      m.content.find(
+        (b) => b.type === "text" && b.text.includes(doomLoopReminder),
+      )
+    );
+  });
+  const lastUserMessageIdx = messages.findLastIndex((m) => {
+    return m.role === "user";
   });
-  const recentToolCalls = toolCalls.slice(-budget);
-  const taskSeen = recentToolCalls.some((call) => call.name === "task");
+  const messagesSinceLast = messages.slice(
+    Math.max(lastReminderIdx, lastUserMessageIdx) + 1,
+  );
+  const minMessagesForReminder = 4;
+
+  if (messagesSinceLast.length < minMessagesForReminder) return toolMessage;
 
-  if (toolCalls.length >= budget && !taskSeen) {
-    output = `<system-reminder>
-You are currently making repeated individual tool calls. This fragments context and reduces efficiency.
+  let errorCount = 0;
+  let sameToolCount = 0;
+  const seenArgs = new Set<string>();
 
-- Stop and plan: consolidate remaining steps into a single **task** tool call.
-- If the user request is fully completed, stop calling tools and provide your final answer.
-</system-reminder>
+  for (const msg of messagesSinceLast) {
+    if (msg.role === "toolResult" && msg.isError) errorCount++;
 
-${output}`;
+    if (msg.role === "assistant") {
+      const calls = msg.content.filter((b) => b.type === "toolCall");
+      for (const c of calls) {
+        const args = JSON.stringify(c.arguments);
+        if (seenArgs.has(args)) sameToolCount++;
+        seenArgs.add(args)
+      }
+    }
   }
 
-  toolMessage.content = [{ type: "text", text: output }];
+  if (
+    errorCount >= minMessagesForReminder ||
+    sameToolCount >= minMessagesForReminder
+  ) {
+    return {
+      ...toolMessage,
+      content: [
+        ...toolMessage.content,
+        { type: "text", text: doomLoopReminder },
+      ],
+    };
+  }
 
   return toolMessage;
 }

package/src/session.ts

@@ -1,6 +1,6 @@
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import type { Message } from "@mariozechner/pi-ai";
+import type { Message } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
 import { SESSIONS_DIR } from "./shared";
 import { type Session, SessionSchema } from "./types";

package/src/tool-bash.ts

@@ -1,24 +1,12 @@
-import { type Tool, Type } from "@mariozechner/pi-ai";
+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
+const description = `Bash CLI tool
 
 Execute shell commands on the user's environment.
 
-Best practices:
-
-- Use \`ls\` to list files.
-- Use \`fd\` or \`find\` to locate files/directories by name, type, size, time, permissions, etc.
-- Use \`rg\` or \`grep\` to search inside files for matching patterns.
-- Use \`cat -n\` or \`nl\` to read small files, or when you need the whole file.
-- Use \`sed -n\` with ranges to read sections of files. Prefer targeted reads. Avoid dumping very large (more than ~200 lines) files all at once.
-- Use \`cp\`, \`mv\`, and \`mkdir\` for file and directory operations, and \`rm\` to remove files and directories.
-- Use \`curl\` for web access. Use redirection to temp files for targeted reads.
-- Use development tools like \`git\`, \`gh\`, \`jq\`, etc, when appropriate.
-- Prefer \`cp -i\`, \`mv -i\`, \`rm -i\` when learning.
-- NEVER run destructive commands (\`rm -rf\`, \`git reset --hard\`, overwriting files) without confirming the target first.
 - Chain commands **only** when failure should stop the flow. Avoid long chains, **2 to 3 maximum**.
 - Avoid overly complex one-liners; readability matters.
 - Quote filenames: use \`"$file"\` not \`$file\`.

package/src/tool-edit.ts

@@ -1,35 +1,23 @@
 import { isAbsolute, join } from "node:path";
-import { type Tool, Type } from "@mariozechner/pi-ai";
+import { type Tool, Type } from "@earendil-works/pi-ai";
 import { createPatch } from "diff";
 import type { ToolRunnerEvent } from "./types";
 
-const description = `## Edit tool
+const description = `Edit tool
 
 A find-and-replace file editor. Use it to create new files or modify existing ones safely. Always prefer this tool over bash editing methods (sed, awk, etc).
 
-### Rules
+Rules
+
 - The tool refuses to edit on multiple matches of \`oldText\`. Be specific with your matching text.
 - Prefer patch-based edits (small targeted replacements) for multi-line or semantic changes.
 - Do NOT reproduce entire files. Use shell file operations (\`cp\`, \`mv\`, etc) for wholesale file replacement instead.
 
-### Failure modes
+Failure modes
+
 - If \`oldText\` is not found, the edit fails. Verify the exact text first.
 - If \`oldText\` matches multiple locations, the edit fails. Narrow your match and retry.
 - If the file does not exist and \`oldText\` is non-empty, the edit fails.
-
-<example>
-Edit a single line:
-path: src/utils.ts
-oldText: const MAX_RETRIES = 3;
-newText: const MAX_RETRIES = 5;
-</example>
-
-<example>
-Patch-based edit (preferred for multi-line changes):
-path: src/utils.ts
-oldText: function oldHelper() {\n  return 1;\n}
-newText: function newHelper() {\n  return 2;\n}\n\nfunction oldHelper() {\n  return 1;\n}
-</example>
 `;
 
 export const edit: Tool = {
@@ -126,7 +114,7 @@ export async function* runEditTool(
 
   yield {
     type: "result",
-    text: `File edited: ${filePath}\n\n${patch}`,
+    text: patch,
   };
 
   return;

package/src/tool-read.ts

@@ -0,0 +1,100 @@
+import { Buffer } from "node:buffer";
+import { extname, isAbsolute, join } from "node:path";
+import { type Tool, Type } from "@earendil-works/pi-ai";
+import type { ToolRunnerEvent } from "./types";
+
+const imageMimeTypes: Record<string, string> = {
+  ".bmp": "image/bmp",
+  ".gif": "image/gif",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+};
+
+const description = `Read tool
+
+Read a file by path.
+
+For text files, returns line-numbered text. Use \`offset\` and \`limit\` to read a specific range.
+You can also read images files.
+`;
+
+export const read: Tool = {
+  name: "read",
+  description,
+  parameters: Type.Object({
+    path: Type.String({
+      description:
+        "File path. Absolute or relative to the current working directory.",
+    }),
+    offset: Type.Optional(
+      Type.Number({
+        description:
+          "Optional 1-based line number to start reading from. Text files only.",
+      }),
+    ),
+    limit: Type.Optional(
+      Type.Number({
+        description:
+          "Optional maximum number of lines to read. Text files only.",
+      }),
+    ),
+  }),
+};
+
+export async function* runReadTool(
+  args: Record<string, any>,
+  signal?: AbortSignal,
+): AsyncGenerator<ToolRunnerEvent> {
+  const filePath = isAbsolute(args.path)
+    ? args.path
+    : join(process.cwd(), args.path);
+  const file = Bun.file(filePath);
+  const exists = await file.exists();
+
+  if (!exists) {
+    yield { type: "result", text: `File not found: ${filePath}` };
+    return;
+  }
+
+  if (signal?.aborted) {
+    yield { type: "result", text: "Aborted before read." };
+    return;
+  }
+
+  const mimeType = imageMimeTypes[extname(filePath).toLowerCase()] ?? file.type;
+  if (mimeType.startsWith("image/")) {
+    const data = Buffer.from(await file.arrayBuffer()).toString("base64");
+    const text = `Image read: ${filePath}\nMIME type: ${mimeType}\nSize: ${file.size} bytes`;
+    yield {
+      type: "result",
+      text,
+      image: { data, mimeType },
+    };
+    return;
+  }
+
+  const content = await file.text();
+  const lines = content.split(/\r?\n/);
+  if (content.endsWith("\n")) lines.pop();
+
+  const offset = args.offset ?? 1;
+  const startIndex = offset - 1;
+  const endIndex = args.limit
+    ? Math.min(lines.length, startIndex + args.limit)
+    : lines.length;
+  const width = String(endIndex).length;
+  const body = lines
+    .slice(startIndex, endIndex)
+    .map((line, idx) => `${String(offset + idx).padStart(width)} | ${line}`)
+    .join("\n");
+
+  let text = `File: ${filePath}\nLines: ${offset}-${endIndex} of ${lines.length}\n\n${body}`;
+  if (endIndex < lines.length) {
+    text += `\n\nMore lines available. Use offset ${endIndex + 1} to continue.`;
+  }
+
+  yield { type: "result", text };
+}

package/src/tui-components.ts

@@ -114,11 +114,11 @@ export function ContextPill(state: TUIState) {
     const smartPercent = Math.floor((state.contextSize / smartMax) * 100);
     if (smartPercent > 90) {
       bg = theme.bred;
-    } else if (smartPercent > 80) {
+    } else if (smartPercent > 85) {
       bg = theme.red;
-    } else if (smartPercent > 70) {
+    } else if (smartPercent > 80) {
       bg = theme.yellow;
-    } else if (smartPercent > 50) {
+    } else if (smartPercent > 60) {
       bg = theme.byellow;
     }
     text = `~${percent}%`;
@@ -126,7 +126,7 @@ export function ContextPill(state: TUIState) {
 
   text += ` (${state.options.model.contextWindow / 1000}k)`;
 
-  return TextPill(text, theme.bblack, bg);
+  return TextPill(text, theme.black, bg);
 }
 
 export function GitPill(state: TUIState) {
@@ -137,13 +137,13 @@ export function ModelPill(state: TUIState) {
   // Like loot: Gold/purple/blue/green/white -> xhigh/high/medium/low/minimal
   switch (state.options.effort) {
     case "xhigh":
-      return TextPill(state.options.model.name, theme.white, theme.yellow);
+      return TextPill(state.options.model.name, theme.black, theme.yellow);
     case "high":
-      return TextPill(state.options.model.name, theme.white, theme.magenta);
+      return TextPill(state.options.model.name, theme.black, theme.magenta);
     case "medium":
-      return TextPill(state.options.model.name, theme.white, theme.blue);
+      return TextPill(state.options.model.name, theme.black, theme.blue);
     case "low":
-      return TextPill(state.options.model.name, theme.white, theme.green);
+      return TextPill(state.options.model.name, theme.black, theme.green);
   }
   // Minimal
   return TextPill(state.options.model.name, theme.bwhite, theme.bblack);

package/src/tui-conversation.ts

@@ -5,7 +5,7 @@ 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";
@@ -33,9 +33,6 @@ function agentMessageNode(msg: AssistantMessage): Node {
       } else if ("command" in block.arguments) {
         text = block.arguments.command;
         node = SyntaxHighlight(text, "bash");
-      } else if ("prompt" in block.arguments) {
-        text = block.arguments.prompt;
-        node = SyntaxHighlight(text, "markdown");
       } else {
         text = JSON.stringify(block.arguments);
         node = Text(text);
@@ -119,22 +116,33 @@ function userMessageNode(msg: UserMessage): Node {
 }
 
 function toolMessageNode(msg: ToolResultMessage): Node {
+  // TODO: read tool image output
   // Output only shows last 10 lines of scroll.
-  return VStack(
-    {
-      height: 10,
-      padding: { x: 4 },
-      overflow: "scroll",
-      scrollOffset: Infinity,
-      onScroll: () => false,
-    },
-    msg.content.map((block) => {
-      if (block.type === "text") {
-        return Text(block.text, { wrap: "word", fgColor: theme.bblack });
-      }
-      return Text(""); // TODO: image case needs attention
+  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 }>();
@@ -190,6 +198,7 @@ function cachedMessageBody(msg: Message): 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" }, [
@@ -197,7 +206,7 @@ function conversationMessageNode(msg: Message): Node {
         fgColor: theme.bblack,
         italic: true,
       }),
-      TextPill(msg.role, theme.bwhite, theme.bblack),
+      TextPill(label, theme.bwhite, theme.bblack),
     ]),
   ]);
 }
@@ -249,7 +258,7 @@ export function Conversation(state: TUIState) {
   return VStack(
     {
       flex: 1,
-      gap: 1,
+      gap: 3,
       overflow: "scroll",
       scrollOffset: state.stickToBottom ? Infinity : state.scrollOffset,
       onScroll(offset, maxOffset) {

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

@@ -11,7 +11,7 @@ import { updateSession } from "./session";
 import { estimateTokens, secureRandomString } from "./shared";
 import { bash, runBashTool } from "./tool-bash";
 import { edit, runEditTool } from "./tool-edit";
-import { runTaskTool, task } from "./tool-task";
+import { read, runReadTool } from "./tool-read";
 import {
   ActivityPill,
   ContextPill,
@@ -43,7 +43,6 @@ function clearOrAbort(state: TUIState) {
 
 export function initTUI(state: TUIState, leave: (s: string) => void) {
   // TODO: Cleanup accumulated sessions for this cwd.
-
   const { spinnerEvery, currentSpinner } = Spinner();
 
   // Stable 60fps rendering.
@@ -147,10 +146,7 @@ async function streamAgentTUI(state: TUIState) {
   const tools: ToolAndRunner[] = [
     { tool: bash, runner: runBashTool },
     { tool: edit, runner: runEditTool },
-    {
-      tool: task,
-      runner: (args, signal) => runTaskTool(state.options, args, signal),
-    },
+    { tool: read, runner: runReadTool },
   ];
 
   let userContent = state.prompt;

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([
@@ -129,7 +129,11 @@ export type AgentToolEvent =
 
 export type ToolRunnerEvent =
   | { type: "output"; text: string }
-  | { type: "result"; text: string };
+  | {
+      type: "result";
+      text: string;
+      image?: { data: string; mimeType: string };
+    };
 
 export type ToolAndRunner = {
   tool: Tool;