mini-coder 0.5.14 → 0.6.1

package/src/tool-read.ts

@@ -1,313 +1,100 @@
-/**
- * Read-tool implementation and read-specific helpers.
- *
- * @module
- */
-
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { isAbsolute, join } from "node:path";
-import type { Static, Tool } from "@mariozechner/pi-ai";
-import { Type } from "@mariozechner/pi-ai";
-import type { ToolHandler, ToolUpdateCallback } from "./agent.ts";
-import {
-  type ToolExecResult,
-  textResult,
-  validateBuiltinToolArgs,
-} from "./tool-common.ts";
-
-const readToolParameters = Type.Object({
-  path: Type.String({
-    description: "File path (absolute or relative to cwd)",
-  }),
-  offset: Type.Optional(
-    Type.Integer({
-      minimum: 0,
-      description: "Zero-based line offset to start reading from",
-    }),
-  ),
-  limit: Type.Optional(
-    Type.Integer({
-      minimum: 1,
-      description: "Maximum number of lines to read in this call",
-    }),
-  ),
-});
-
-/** Default line window returned when `limit` is omitted. */
-export const DEFAULT_READ_LIMIT = 200;
-
-/** Number of logical lines to append between progressive UI updates. */
-const READ_STREAM_CHUNK_LINES = 40;
+import { Buffer } from "node:buffer";
+import { extname, isAbsolute, join } from "node:path";
+import { type Tool, Type } from "@mariozechner/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",
+};
 
-/** Arguments for the `read` tool. */
-export type ReadArgs = Static<typeof readToolParameters>;
+const description = `## Read tool
 
-/** Continuation metadata parsed from a successful read result. */
-export interface ReadContinuationHint {
-  /** Next zero-based line offset to request. */
-  offset: number;
-  /** Suggested line limit for the follow-up read. */
-  limit: number;
-}
+Read a file by path.
 
-/** Options for read execution. */
-export interface ReadOpts {
-  /** Abort signal for interruption. */
-  signal?: AbortSignal;
-  /** Callback for progressive content updates. */
-  onUpdate?: ToolUpdateCallback;
-}
+For text files, returns line-numbered text. Use \`offset\` and \`limit\` to read a specific range.
+You can also read images files.
+`;
 
-/** pi-ai tool definition for `read`. */
-export const readTool: Tool<typeof readToolParameters> = {
+export const read: Tool = {
   name: "read",
-  description:
-    "Read a UTF-8 text file from disk. " +
-    "Takes a file path plus optional line-based `offset` and `limit`. " +
-    "Prefer this tool over shelling out to `cat`, `sed`, `head`, or `tail` when you need file contents.",
-  parameters: readToolParameters,
+  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.",
+      }),
+    ),
+  }),
 };
 
-function resolveReadPath(path: string, cwd: string): string {
-  return isAbsolute(path) ? path : join(cwd, path);
-}
-
-function splitLinesPreservingEndings(content: string): string[] {
-  if (content === "") {
-    return [];
-  }
-
-  const lines: string[] = [];
-  let start = 0;
-
-  for (let index = 0; index < content.length; index++) {
-    const char = content[index];
-    if (char === "\n") {
-      lines.push(content.slice(start, index + 1));
-      start = index + 1;
-      continue;
-    }
-    if (char === "\r" && content[index + 1] === "\n") {
-      lines.push(content.slice(start, index + 2));
-      start = index + 2;
-      index += 1;
-    }
-  }
-
-  if (start < content.length) {
-    lines.push(content.slice(start));
-  }
-
-  return lines;
-}
-
-function waitForNextTick(): Promise<void> {
-  return new Promise((resolve) => setImmediate(resolve));
-}
-
-/** Format the trailing continuation hint appended to truncated read results. */
-export function formatReadContinuationHint(
-  offset: number,
-  limit: number,
-): string {
-  return `[use offset=${offset} limit=${limit} to continue]`;
-}
-
-/** Parse a standalone read continuation hint block. */
-export function parseReadContinuationHint(
-  text: string,
-): ReadContinuationHint | null {
-  const match = /^\[use offset=(\d+) limit=(\d+) to continue\]$/.exec(text);
-  if (!match) {
-    return null;
-  }
-
-  const offsetText = match[1];
-  const limitText = match[2];
-  if (!offsetText || !limitText) {
-    return null;
-  }
-
-  return {
-    offset: Number.parseInt(offsetText, 10),
-    limit: Number.parseInt(limitText, 10),
-  };
-}
-
-/** Parse a legacy flattened read result into file content plus any continuation hint. */
-export function parseReadResult(text: string): {
-  body: string;
-  continuation: ReadContinuationHint | null;
-} {
-  const trailerMatch =
-    /(?:\r?\n){2}(\[use offset=\d+ limit=\d+ to continue\])$/.exec(text);
-  if (!trailerMatch) {
-    return { body: text, continuation: null };
-  }
-
-  const continuation = parseReadContinuationHint(trailerMatch[1] ?? "");
-  if (!continuation) {
-    return { body: text, continuation: null };
-  }
-
-  return {
-    body: text.slice(0, trailerMatch.index),
-    continuation,
-  };
-}
-
-async function streamReadPreview(
-  lines: readonly string[],
-  opts: ReadOpts | undefined,
-): Promise<void> {
-  if (!opts?.onUpdate || lines.length === 0) {
+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;
   }
 
-  const chunkSize = Math.max(1, READ_STREAM_CHUNK_LINES);
-  for (let index = chunkSize; index < lines.length; index += chunkSize) {
-    if (opts.signal?.aborted) {
-      return;
-    }
-
-    opts.onUpdate(textResult(lines.slice(0, index).join(""), false));
-    await waitForNextTick();
-  }
-}
-
-function loadReadContent(
-  args: ReadArgs,
-  cwd: string,
-): ToolExecResult | { content: string } {
-  const filePath = resolveReadPath(args.path, cwd);
-  if (!existsSync(filePath)) {
-    return textResult(`File not found: ${args.path}`, true);
-  }
-
-  try {
-    if (!statSync(filePath).isFile()) {
-      return textResult(`Not a file: ${args.path}`, true);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return textResult(`Failed to stat ${args.path}: ${message}`, true);
+  if (signal?.aborted) {
+    yield { type: "result", text: "Aborted before read." };
+    return;
   }
 
-  try {
-    return {
-      content: readFileSync(filePath, "utf-8"),
+  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 },
     };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return textResult(`Failed to read ${args.path}: ${message}`, true);
-  }
-}
-
-function getReadSlice(
-  args: ReadArgs,
-  content: string,
-):
-  | ToolExecResult
-  | {
-      lines: string[];
-      offset: number;
-      limit: number;
-    } {
-  const lines = splitLinesPreservingEndings(content);
-  const offset = args.offset ?? 0;
-  const limit = args.limit ?? DEFAULT_READ_LIMIT;
-
-  if (offset > lines.length || (lines.length > 0 && offset === lines.length)) {
-    return textResult(
-      `Offset ${offset} is out of range for ${args.path} (${lines.length} lines)`,
-      true,
-    );
-  }
-
-  return {
-    lines: lines.slice(offset, offset + limit),
-    offset,
-    limit,
-  };
-}
-
-function buildReadResult(
-  body: string,
-  continuation: ReadContinuationHint | null,
-): ToolExecResult {
-  if (!continuation) {
-    return textResult(body, false);
-  }
-
-  return {
-    content: [
-      { type: "text", text: body },
-      {
-        type: "text",
-        text: formatReadContinuationHint(
-          continuation.offset,
-          continuation.limit,
-        ),
-      },
-    ],
-    isError: false,
-  };
-}
-
-/**
- * Read a UTF-8 text file, optionally by line window.
- *
- * When `limit` is omitted, the tool returns a bounded initial slice and adds a
- * continuation hint when more content remains.
- *
- * @param args - Read arguments.
- * @param cwd - Working directory for resolving relative paths.
- * @param opts - Optional abort signal and progressive update callback.
- * @returns A text tool result containing file content or an error.
- */
-export async function executeRead(
-  args: ReadArgs,
-  cwd: string,
-  opts?: ReadOpts,
-): Promise<ToolExecResult> {
-  const loaded = loadReadContent(args, cwd);
-  if ("isError" in loaded) {
-    return loaded;
+    return;
   }
 
-  const slice = getReadSlice(args, loaded.content);
-  if ("isError" in slice) {
-    return slice;
-  }
+  const content = await file.text();
+  const lines = content.split(/\r?\n/);
+  if (content.endsWith("\n")) lines.pop();
 
-  await streamReadPreview(slice.lines, opts);
-  if (opts?.signal?.aborted) {
-    return textResult("Read aborted", true);
-  }
+  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");
 
-  const body = slice.lines.join("");
-  const totalLines = splitLinesPreservingEndings(loaded.content).length;
-  if (slice.offset + slice.lines.length >= totalLines) {
-    return buildReadResult(body, null);
+  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.`;
   }
 
-  return buildReadResult(body, {
-    offset: slice.offset + slice.lines.length,
-    limit: slice.limit,
-  });
+  yield { type: "result", text };
 }
-
-/**
- * Tool handler that validates read arguments before execution.
- *
- * @param args - Raw parsed tool-call arguments.
- * @param cwd - Working directory for path resolution.
- * @param signal - Optional abort signal.
- * @param onUpdate - Optional progressive output callback.
- * @returns The read tool result.
- */
-export const readToolHandler: ToolHandler = (args, cwd, signal, onUpdate) =>
-  executeRead(validateBuiltinToolArgs(readTool, args), cwd, {
-    ...(signal ? { signal } : {}),
-    ...(onUpdate ? { onUpdate } : {}),
-  });

package/src/tui-components.ts

@@ -0,0 +1,150 @@
+import { type Color, HStack, Text } from "@cel-tui/core";
+import { onceEvery } from "./shared";
+import type { TUIState } from "./types";
+
+export const theme = {
+  black: "color00" as Color,
+  bblack: "color08" as Color,
+
+  red: "color01" as Color,
+  bred: "color09" as Color,
+
+  green: "color02" as Color,
+  bgreen: "color10" as Color,
+
+  yellow: "color03" as Color,
+  byellow: "color11" as Color,
+
+  blue: "color04" as Color,
+  bblue: "color12" as Color,
+
+  magenta: "color05" as Color,
+  bmagenta: "color13" as Color,
+
+  cyan: "color06" as Color,
+  bcyan: "color14" as Color,
+
+  white: "color07" as Color,
+  bwhite: "color15" as Color,
+};
+
+export function TextPill(
+  content: string,
+  fgColor: Color,
+  bgColor: Color,
+  size?: number | undefined,
+) {
+  return HStack({ gap: 1, width: size }, [
+    HStack({ bgColor, padding: { x: 1 } }, [
+      Text(content, { bold: true, fgColor }),
+    ]),
+  ]);
+}
+
+export function Spinner() {
+  const spinnerFrames = [
+    "⠁",
+    "⠂",
+    "⠄",
+    "⡀",
+    "⡈",
+    "⡐",
+    "⡠",
+    "⣀",
+    "⣁",
+    "⣂",
+    "⣄",
+    "⣌",
+    "⣔",
+    "⣤",
+    "⣥",
+    "⣦",
+    "⣮",
+    "⣶",
+    "⣷",
+    "⣿",
+    "⡿",
+    "⠿",
+    "⢟",
+    "⠟",
+    "⡛",
+    "⠛",
+    "⠫",
+    "⢋",
+    "⠋",
+    "⠍",
+    "⡉",
+    "⠉",
+    "⠑",
+    "⠡",
+    "⢁",
+  ];
+  let spinnerTick = 0;
+  const spinnerEvery = onceEvery(4, () => spinnerTick++);
+  const currentSpinner = () =>
+    spinnerFrames[spinnerTick % spinnerFrames.length];
+
+  return { spinnerEvery, currentSpinner };
+}
+
+export function ActivityPill(state: TUIState, spinnerFrame: string) {
+  let label = "idle";
+  const frame = state.streaming ? spinnerFrame : "";
+
+  if (frame) {
+    label = frame;
+  }
+
+  return Text(label);
+}
+
+export function ContextPill(state: TUIState) {
+  let text = "";
+  let bg = theme.bgreen;
+  if (!state.contextSize) {
+    text = "0%";
+    bg = theme.bwhite;
+  } else {
+    // Colors show the progress in the "smart window" or how much
+    // before the dumb zone. The user facing percentage is the model
+    // amount. An elegant way to show both :)
+    const max = state.options.model.contextWindow;
+    const smartMax = 80000;
+    const percent = Math.floor((state.contextSize / max) * 100);
+    const smartPercent = Math.floor((state.contextSize / smartMax) * 100);
+    if (smartPercent > 90) {
+      bg = theme.bred;
+    } else if (smartPercent > 80) {
+      bg = theme.red;
+    } else if (smartPercent > 70) {
+      bg = theme.yellow;
+    } else if (smartPercent > 50) {
+      bg = theme.byellow;
+    }
+    text = `~${percent}%`;
+  }
+
+  text += ` (${state.options.model.contextWindow / 1000}k)`;
+
+  return TextPill(text, theme.bblack, bg);
+}
+
+export function GitPill(state: TUIState) {
+  return TextPill(state.gitBranch ?? "No git.", theme.bwhite, theme.bblack);
+}
+
+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.black, theme.yellow);
+    case "high":
+      return TextPill(state.options.model.name, theme.black, theme.magenta);
+    case "medium":
+      return TextPill(state.options.model.name, theme.black, theme.blue);
+    case "low":
+      return TextPill(state.options.model.name, theme.black, theme.green);
+  }
+  // Minimal
+  return TextPill(state.options.model.name, theme.bwhite, theme.bblack);
+}