mini-coder 0.7.4 → 0.8.0

package/src/tools/bash.ts

@@ -0,0 +1,89 @@
+import { spawn } from "node:child_process";
+import { Type, type Static } from "@earendil-works/pi-ai";
+import type { ToolContext, ToolResult } from "./common.ts";
+
+export const BASH_PARAMS = Type.Object(
+  { command: Type.String({ description: "Command to run" }) },
+  { additionalProperties: false },
+);
+type BashArgs = Static<typeof BASH_PARAMS>;
+
+const MAX_HEAD = 10_000;
+const MAX_TAIL = 6_000;
+const TRUNCATED = "\n\n... output truncated ...\n\n";
+
+export function bash(args: BashArgs, ctx: ToolContext): Promise<ToolResult> {
+  return new Promise((resolve) => {
+    const child = spawn("bash", ["-c", args.command], {
+      cwd: process.cwd(),
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let head = "";
+    let tail = "";
+    let omitted = 0;
+    const append = (chunk: Buffer) => {
+      let text = chunk.toString();
+      ctx.onOutput?.(text);
+      if (head.length < MAX_HEAD) {
+        const take = Math.min(MAX_HEAD - head.length, text.length);
+        head += text.slice(0, take);
+        text = text.slice(take);
+      }
+      if (text === "") return;
+      tail += text;
+      if (tail.length > MAX_TAIL) {
+        omitted += tail.length - MAX_TAIL;
+        tail = tail.slice(tail.length - MAX_TAIL);
+      }
+    };
+    child.stdout?.on("data", append);
+    child.stderr?.on("data", append);
+
+    let settled = false;
+    const finish = (code: number | null) => {
+      if (settled) return;
+      settled = true;
+      ctx.signal.removeEventListener("abort", onAbort);
+      clearTimeout(killTimer);
+      const exit = code ?? (ctx.signal.aborted ? "aborted" : "unknown");
+      const truncated = omitted > 0;
+      const body = truncated ? head + TRUNCATED + tail : head + tail;
+      const text = body + (body.endsWith("\n") || body === "" ? "" : "\n") + `exit code: ${exit}`;
+      resolve({
+        text,
+        isError: code !== 0,
+        details: truncated
+          ? { truncated: true, omittedChars: omitted, totalChars: head.length + tail.length + omitted }
+          : undefined,
+      });
+    };
+
+    let killTimer: NodeJS.Timeout | undefined;
+    const onAbort = () => {
+      if (!child.pid) return;
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+        /* already gone */
+      }
+      killTimer = setTimeout(() => {
+        try {
+          process.kill(-child.pid!, "SIGKILL");
+        } catch {
+          /* already gone */
+        }
+      }, 300);
+    };
+
+    if (ctx.signal.aborted) onAbort();
+    else ctx.signal.addEventListener("abort", onAbort, { once: true });
+
+    child.on("error", (error) => {
+      append(Buffer.from(`${head || tail ? "\n" : ""}bash failed: ${error.message}\n`));
+      finish(null);
+    });
+    child.on("close", (code) => finish(code));
+  });
+}

package/src/tools/common.ts

@@ -0,0 +1,32 @@
+import type { ImageContent, Static, TSchema } from "@earendil-works/pi-ai";
+import { Value } from "typebox/value";
+
+export interface ToolContext {
+  signal: AbortSignal;
+  /** Whether the current model accepts image input. */
+  supportsImages: boolean;
+  onOutput?: (chunk: string) => void;
+}
+
+export interface ToolDetails {
+  truncated: boolean;
+  omittedChars: number;
+  totalChars: number;
+}
+
+export interface ToolResult {
+  text: string;
+  isError: boolean;
+  details?: ToolDetails;
+  /** Image blocks appended to the tool result, after `text`. */
+  images?: ImageContent[];
+}
+
+export function parseArgs<T extends TSchema>(schema: T, value: unknown): Static<T> {
+  try {
+    return Value.Parse(schema, value);
+  } catch {
+    const first = [...Value.Errors(schema, value)][0];
+    throw new Error(first ? `${first.instancePath || "/"} ${first.message}` : "invalid arguments");
+  }
+}

package/src/tools/edit.ts

@@ -0,0 +1,41 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { Type, type Static } from "@earendil-works/pi-ai";
+import { createTwoFilesPatch } from "diff";
+import type { ToolResult } from "./common.ts";
+
+export const EDIT_PARAMS = Type.Object(
+  {
+    path: Type.String({ description: "File path" }),
+    oldText: Type.String({ description: "Exact text to replace; empty to create a file" }),
+    newText: Type.String({ description: "Replacement text" }),
+  },
+  { additionalProperties: false },
+);
+type EditArgs = Static<typeof EDIT_PARAMS>;
+
+export function edit(args: EditArgs, signal: AbortSignal): ToolResult {
+  const { path, oldText, newText } = args;
+  const exists = existsSync(path);
+
+  if (oldText === "") {
+    if (exists) return { text: `edit failed: ${path} already exists`, isError: true };
+    if (signal.aborted) return { text: "edit cancelled", isError: true };
+    writeFileSync(path, newText);
+    return { text: `created ${path}\n${unified(path, "", newText)}`, isError: false };
+  }
+
+  if (!exists) return { text: `edit failed: ${path} does not exist`, isError: true };
+  const before = readFileSync(path, "utf8");
+  const count = before.split(oldText).length - 1;
+  if (count === 0) return { text: `edit failed: oldText not found in ${path}`, isError: true };
+  if (count > 1) return { text: `edit failed: oldText matches ${count} times in ${path}`, isError: true };
+
+  const after = before.replace(oldText, newText);
+  if (signal.aborted) return { text: "edit cancelled", isError: true };
+  writeFileSync(path, after);
+  return { text: `edited ${path}\n${unified(path, before, after)}`, isError: false };
+}
+
+function unified(path: string, before: string, after: string): string {
+  return createTwoFilesPatch(path, path, before, after, "", "", { context: 3 });
+}

package/src/tools/index.ts

@@ -0,0 +1,47 @@
+import type { Api, Model, Tool, ToolCall } from "@earendil-works/pi-ai";
+import type { ToolName } from "../config.ts";
+import { parseArgs, type ToolContext, type ToolResult } from "./common.ts";
+import { BASH_PARAMS, bash } from "./bash.ts";
+import { EDIT_PARAMS, edit } from "./edit.ts";
+import { READ_PARAMS, read } from "./read.ts";
+
+export type { ToolDetails, ToolResult } from "./common.ts";
+
+/** Whether a model accepts image input. Drives `read`'s description and results. */
+export function acceptsImages(model: Model<Api>): boolean {
+  return model.input.includes("image");
+}
+
+const READ_DESCRIPTION = "Read a file. Returns its text. Prefer bash for search, ranges, or binary files.";
+const READ_IMAGE_DESCRIPTION =
+  "Read a file. Returns its text, or the image itself when the file is a png, jpg, or webp. " +
+  "Prefer bash for search, ranges, or binary files.";
+
+export function toolSchemas(names: ToolName[], withImages: boolean): Tool[] {
+  const tools: Record<ToolName, Tool> = {
+    edit: {
+      name: "edit",
+      description:
+        "Edit a file by exact text replacement. oldText must occur exactly once. " +
+        "With empty oldText, create a new file (fails if it exists).",
+      parameters: EDIT_PARAMS,
+    },
+    read: {
+      name: "read",
+      description: withImages ? READ_IMAGE_DESCRIPTION : READ_DESCRIPTION,
+      parameters: READ_PARAMS,
+    },
+    bash: {
+      name: "bash",
+      description: "Run a bash command in the current working directory.",
+      parameters: BASH_PARAMS,
+    },
+  };
+  return names.map((name) => tools[name]);
+}
+
+export async function executeTool(call: ToolCall, ctx: ToolContext): Promise<ToolResult> {
+  if (call.name === "edit") return edit(parseArgs(EDIT_PARAMS, call.arguments), ctx.signal);
+  if (call.name === "read") return read(parseArgs(READ_PARAMS, call.arguments), ctx);
+  return bash(parseArgs(BASH_PARAMS, call.arguments), ctx);
+}

package/src/tools/read.ts

@@ -0,0 +1,64 @@
+import { readFileSync } from "node:fs";
+import { extname } from "node:path";
+import { Type, type Static } from "@earendil-works/pi-ai";
+import type { ToolContext, ToolResult } from "./common.ts";
+
+export const READ_PARAMS = Type.Object(
+  { path: Type.String({ description: "File path" }) },
+  { additionalProperties: false },
+);
+type ReadArgs = Static<typeof READ_PARAMS>;
+
+const IMAGE_MIME: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+};
+
+const MAX_TEXT_CHARS = 100_000;
+/** Cap on the base64 payload sent to the provider, where the file inflates by 4/3. */
+const MAX_IMAGE_BASE64_BYTES = 5 * 1024 * 1024;
+
+export function read(args: ReadArgs, ctx: ToolContext): ToolResult {
+  const { path } = args;
+
+  let data: Buffer;
+  try {
+    data = readFileSync(path);
+  } catch (error) {
+    return { text: `read failed: ${(error as Error).message}`, isError: true };
+  }
+
+  const mime = IMAGE_MIME[extname(path).slice(1).toLowerCase()];
+  if (mime !== undefined) {
+    if (!ctx.supportsImages) {
+      return { text: `read failed: ${path} is an image and the current model does not accept image input`, isError: true };
+    }
+    const base64 = data.toString("base64");
+    if (base64.length > MAX_IMAGE_BASE64_BYTES) {
+      return {
+        text: `read failed: ${path} encodes to ${base64.length} bytes, over the ${MAX_IMAGE_BASE64_BYTES} byte image limit`,
+        isError: true,
+      };
+    }
+    return {
+      text: `read ${path} (${mime}, ${data.length} bytes)`,
+      isError: false,
+      images: [{ type: "image", data: base64, mimeType: mime }],
+    };
+  }
+
+  if (data.subarray(0, 8000).includes(0)) {
+    return { text: `read failed: ${path} is binary; use bash (file, xxd)`, isError: true };
+  }
+
+  const text = data.toString("utf8");
+  if (text.length > MAX_TEXT_CHARS) {
+    return {
+      text: text.slice(0, MAX_TEXT_CHARS) + `\n\n... truncated ... ${path} is ${text.length} characters\n`,
+      isError: false,
+    };
+  }
+  return { text, isError: false };
+}

package/src/tui/commands.ts

@@ -0,0 +1,63 @@
+import { dim } from "./styles.ts";
+
+export interface CommandContext {
+  /** Appends already-styled lines to scrollback. */
+  write(lines: string[]): void;
+}
+
+interface Command {
+  name: string; // no leading slash, lowercase
+  description: string; // one line, shown by /help
+  run(ctx: CommandContext, args: string): void;
+}
+
+/** The keybindings the TUI accepts, in the order `/help` prints them. */
+const KEYBINDINGS: [string, string][] = [
+  ["Enter", "submit"],
+  ["Shift+Enter", "newline (Ctrl+J also works)"],
+  ["Esc", "pause the turn at the next step boundary"],
+  ["Ctrl+C", "cancel the turn"],
+  ["Ctrl+D", "exit on an empty draft"],
+];
+
+/** One aligned `key  description` block; the key column is dimmed. */
+function keyed(rows: [string, string][], width: number): string[] {
+  return rows.map(([key, description]) => `  ${dim(key.padEnd(width))}  ${description}`);
+}
+
+const help: Command = {
+  name: "help",
+  description: "list commands and keybindings",
+  run(ctx): void {
+    const names = COMMANDS.map((command): [string, string] => [`/${command.name}`, command.description]);
+    const width = Math.max(...names.map(([key]) => key.length), ...KEYBINDINGS.map(([key]) => key.length));
+    ctx.write(["commands", ...keyed(names, width), "", "keybindings", ...keyed(KEYBINDINGS, width)]);
+  },
+};
+
+const COMMANDS: Command[] = [help];
+
+/** `/name args` for a known `name`, else null; unknown slash text stays a message. */
+export function findCommand(text: string): { command: Command; args: string } | null {
+  const match = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(text);
+  if (match === null) return null;
+  const command = COMMANDS.find((candidate) => candidate.name === match[1]);
+  return command === undefined ? null : { command, args: match[2] ?? "" };
+}
+
+/** Tab completion for a half-typed command name; null leaves the draft alone. */
+export function completeCommand(draft: string): string | null {
+  if (!draft.startsWith("/") || /\s/.test(draft)) return null;
+  const typed = draft.slice(1);
+  const matches = COMMANDS.filter((command) => command.name.startsWith(typed));
+  if (matches.length === 0) return null;
+  if (matches.length === 1) return `/${matches[0].name}`;
+  const shared = matches.map((command) => command.name).reduce(commonPrefix);
+  return shared === typed ? null : `/${shared}`;
+}
+
+function commonPrefix(a: string, b: string): string {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i++;
+  return a.slice(0, i);
+}

package/src/tui/editor.ts

@@ -0,0 +1,291 @@
+import { displayWidth, expandTabs, wrapLine, type Key } from "./term.ts";
+
+const TAB = 4;
+const DEFAULT_WIDTH = 80;
+
+function codePoints(line: string): string[] {
+  return Array.from(line);
+}
+
+function isSpace(ch: string): boolean {
+  return /\s/u.test(ch);
+}
+
+/** First code point index of the word before `col`; shared by all word motion. */
+function wordStart(cps: string[], col: number): number {
+  let i = col;
+  while (i > 0 && isSpace(cps[i - 1])) i--;
+  while (i > 0 && !isSpace(cps[i - 1])) i--;
+  return i;
+}
+
+/** Code point index one past the word at or after `col`. */
+function wordEnd(cps: string[], col: number): number {
+  let i = col;
+  while (i < cps.length && isSpace(cps[i])) i++;
+  while (i < cps.length && !isSpace(cps[i])) i++;
+  return i;
+}
+
+interface EditorRender {
+  rows: string[];
+  cursorRow: number;
+  cursorCol: number;
+}
+
+export class Editor {
+  private lines: string[] = [""];
+  private row = 0;
+  private col = 0;
+  private scroll = 0;
+  private width = DEFAULT_WIDTH;
+
+  text(): string {
+    return this.lines.join("\n");
+  }
+
+  clear(): void {
+    this.lines = [""];
+    this.row = 0;
+    this.col = 0;
+    this.scroll = 0;
+  }
+
+  setText(text: string): void {
+    this.lines = text.split("\n");
+    this.row = this.lines.length - 1;
+    this.col = codePoints(this.lines[this.row]).length;
+    this.scroll = 0;
+  }
+
+  handle(key: Key): "submit" | "changed" | "none" {
+    switch (key.type) {
+      case "submit":
+        return "submit";
+      case "newline":
+        this.insert("\n");
+        return "changed";
+      case "text":
+        this.insert(key.text);
+        return "changed";
+      case "backspace":
+        this.backspace();
+        return "changed";
+      case "delete":
+        this.deleteForward();
+        return "changed";
+      case "wordBack":
+        this.wordBack();
+        return "changed";
+      case "left":
+        this.left();
+        return "changed";
+      case "right":
+        this.right();
+        return "changed";
+      case "wordLeft":
+        this.wordLeft();
+        return "changed";
+      case "wordRight":
+        this.wordRight();
+        return "changed";
+      case "up":
+        this.up();
+        return "changed";
+      case "down":
+        this.down();
+        return "changed";
+      case "home":
+        this.col = 0;
+        return "changed";
+      case "end":
+        this.col = codePoints(this.lines[this.row]).length;
+        return "changed";
+      case "docStart":
+        this.row = 0;
+        this.col = 0;
+        return "changed";
+      case "docEnd":
+        this.row = this.lines.length - 1;
+        this.col = codePoints(this.lines[this.row]).length;
+        return "changed";
+      default:
+        return "none";
+    }
+  }
+
+  /** Clipped to `maxRows`, scrolled only as far as the caret requires. */
+  render(width: number, maxRows: number): EditorRender {
+    this.width = Math.max(1, width);
+    const rows: string[] = [];
+    let cursorRow = 0;
+    let cursorCol = 0;
+    for (let line = 0; line < this.lines.length; line++) {
+      const chunks = wrapLine(expandTabs(this.lines[line], TAB), this.width);
+      if (line === this.row) {
+        const caret = this.caret();
+        cursorRow = rows.length + caret.row;
+        cursorCol = caret.col;
+      }
+      rows.push(...chunks);
+    }
+    const view = Math.max(1, maxRows);
+    if (cursorRow < this.scroll) this.scroll = cursorRow;
+    else if (cursorRow >= this.scroll + view) this.scroll = cursorRow - view + 1;
+    this.scroll = Math.min(Math.max(this.scroll, 0), Math.max(0, rows.length - view));
+    return {
+      rows: rows.slice(this.scroll, this.scroll + view),
+      cursorRow: cursorRow - this.scroll,
+      cursorCol,
+    };
+  }
+
+  /** The caret's display row within its logical line, and its cell column. */
+  private caret(): { row: number; col: number } {
+    const line = this.lines[this.row];
+    const chunks = wrapLine(expandTabs(line, TAB), this.width);
+    const cell = this.cells(line)[this.col];
+    const row = Math.floor(cell / this.width);
+    if (row >= chunks.length) return { row: chunks.length - 1, col: displayWidth(chunks[chunks.length - 1]) };
+    return { row, col: cell - row * this.width };
+  }
+
+  /** Display column of every code point boundary in `line`, tabs expanded. */
+  private cells(line: string): number[] {
+    const out = [0];
+    let col = 0;
+    for (const ch of codePoints(line)) {
+      col += ch === "\t" ? TAB - (col % TAB) : displayWidth(ch);
+      out.push(col);
+    }
+    return out;
+  }
+
+  /** The caret column nearest `cell`, never past the end of the line. */
+  private colAtCell(line: string, cell: number): number {
+    const cells = this.cells(line);
+    let i = cells.length - 1;
+    while (i > 0 && cells[i] > cell) i--;
+    return i;
+  }
+
+  private insert(text: string): void {
+    const parts = text.split("\n");
+    const current = codePoints(this.lines[this.row]);
+    const before = current.slice(0, this.col).join("");
+    const after = current.slice(this.col).join("");
+    if (parts.length === 1) {
+      this.lines[this.row] = before + parts[0] + after;
+      this.col += codePoints(parts[0]).length;
+      return;
+    }
+    const head = before + parts[0];
+    const tail = parts[parts.length - 1] + after;
+    this.lines.splice(this.row, 1, head, ...parts.slice(1, -1), tail);
+    this.row += parts.length - 1;
+    this.col = codePoints(parts[parts.length - 1]).length;
+  }
+
+  private backspace(): void {
+    if (this.col > 0) {
+      const current = codePoints(this.lines[this.row]);
+      this.lines[this.row] = current.slice(0, this.col - 1).join("") + current.slice(this.col).join("");
+      this.col--;
+      return;
+    }
+    if (this.row > 0) {
+      const previous = codePoints(this.lines[this.row - 1]).length;
+      this.lines[this.row - 1] += this.lines[this.row];
+      this.lines.splice(this.row, 1);
+      this.row--;
+      this.col = previous;
+    }
+  }
+
+  private deleteForward(): void {
+    const current = codePoints(this.lines[this.row]);
+    if (this.col < current.length) {
+      this.lines[this.row] = current.slice(0, this.col).join("") + current.slice(this.col + 1).join("");
+      return;
+    }
+    if (this.row < this.lines.length - 1) {
+      this.lines[this.row] += this.lines[this.row + 1];
+      this.lines.splice(this.row + 1, 1);
+    }
+  }
+
+  private left(): void {
+    if (this.col > 0) this.col--;
+    else if (this.row > 0) {
+      this.row--;
+      this.col = codePoints(this.lines[this.row]).length;
+    }
+  }
+
+  private right(): void {
+    if (this.col < codePoints(this.lines[this.row]).length) this.col++;
+    else if (this.row < this.lines.length - 1) {
+      this.row++;
+      this.col = 0;
+    }
+  }
+
+  /** One display row, so the caret crosses the wrapped rows of a long line. */
+  private up(): void {
+    const line = this.lines[this.row];
+    const caret = this.caret();
+    if (caret.row > 0) {
+      this.col = this.colAtCell(line, this.cells(line)[this.col] - this.width);
+      return;
+    }
+    if (this.row === 0) return;
+    this.row--;
+    const previous = this.lines[this.row];
+    const lastRow = wrapLine(expandTabs(previous, TAB), this.width).length - 1;
+    this.col = this.colAtCell(previous, lastRow * this.width + caret.col);
+  }
+
+  private down(): void {
+    const line = this.lines[this.row];
+    const caret = this.caret();
+    if (caret.row < wrapLine(expandTabs(line, TAB), this.width).length - 1) {
+      this.col = this.colAtCell(line, this.cells(line)[this.col] + this.width);
+      return;
+    }
+    if (this.row === this.lines.length - 1) return;
+    this.row++;
+    this.col = this.colAtCell(this.lines[this.row], caret.col);
+  }
+
+  private wordLeft(): void {
+    const cps = codePoints(this.lines[this.row]);
+    const start = wordStart(cps, this.col);
+    if (start !== this.col) {
+      this.col = start;
+      return;
+    }
+    if (this.row === 0) return;
+    this.row--;
+    const previous = codePoints(this.lines[this.row]);
+    this.col = wordStart(previous, previous.length);
+  }
+
+  private wordRight(): void {
+    const cps = codePoints(this.lines[this.row]);
+    const end = wordEnd(cps, this.col);
+    if (end !== this.col) {
+      this.col = end;
+      return;
+    }
+    if (this.row === this.lines.length - 1) return;
+    this.row++;
+    this.col = wordEnd(codePoints(this.lines[this.row]), 0);
+  }
+
+  private wordBack(): void {
+    const current = codePoints(this.lines[this.row]);
+    const start = wordStart(current, this.col);
+    this.lines[this.row] = current.slice(0, start).join("") + current.slice(this.col).join("");
+    this.col = start;
+  }
+}