mini-coder 0.5.6 → 0.5.8

package/src/headless.ts

@@ -4,6 +4,8 @@
  * @module
  */
 
+import type { AssistantMessage, UserMessage } from "@mariozechner/pi-ai";
+import type { AgentEvent } from "./agent.ts";
 import type { AppState } from "./index.ts";
 import {
   resolveRawInput,
@@ -15,18 +17,37 @@ import {
 // Types
 // ---------------------------------------------------------------------------
 
-/** Options for a headless one-shot run. */
+type HeadlessStopReason = "stop" | "length" | "error" | "aborted";
+
+/** Options for a headless NDJSON run. */
 export interface HeadlessRunOptions {
-  /** Optional line writer for NDJSON event output. */
+  /** Optional line writer for completed NDJSON event output. */
   writeLine?: (line: string) => void;
 }
 
+/** Options for a headless final-text run. */
+export interface HeadlessTextRunOptions {
+  /** Optional writer for the final assistant text output. */
+  writeText?: (text: string) => void;
+}
+
+interface HeadlessOutputController {
+  /** Write text to stdout with broken-pipe handling. */
+  write(text: string): void;
+  /** Attach SIGINT/stdout error handlers for the active run. */
+  attach(): void;
+  /** Remove SIGINT/stdout error handlers after the run. */
+  detach(): void;
+  /** Resolve the final stop reason, converting broken pipes into quiet shutdowns. */
+  finalize(stopReason: HeadlessStopReason): HeadlessStopReason;
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function defaultWriteLine(line: string): void {
-  process.stdout.write(`${line}\n`);
+function defaultWrite(text: string): void {
+  process.stdout.write(text);
 }
 
 function isBrokenPipeError(error: unknown): boolean {
@@ -52,23 +73,10 @@ function buildCommandError(command: string): Error {
   );
 }
 
-/**
- * Run a single headless prompt to completion and stream NDJSON events.
- *
- * The raw input is parsed with the same rules as interactive input. Slash
- * commands are rejected in headless mode. Assistant/tool events are written as
- * one JSON object per line.
- *
- * @param state - Mutable application state for the run.
- * @param rawInput - Exact raw prompt text supplied by the user.
- * @param options - Optional event-output overrides.
- * @returns The terminal stop reason for the agent loop.
- */
-export async function runHeadlessPrompt(
+function resolveHeadlessContent(
   state: AppState,
   rawInput: string,
-  options?: HeadlessRunOptions,
-): Promise<"stop" | "length" | "error" | "aborted"> {
+): UserMessage["content"] {
   const resolved = resolveRawInput(rawInput, state);
   switch (resolved.type) {
     case "empty":
@@ -78,11 +86,52 @@ export async function runHeadlessPrompt(
     case "command":
       throw buildCommandError(resolved.command);
     case "message":
-      break;
+      return resolved.content;
+  }
+}
+
+function extractAssistantText(message: AssistantMessage | null): string {
+  if (!message) {
+    return "";
   }
 
+  return message.content
+    .filter(
+      (
+        block,
+      ): block is Extract<
+        AssistantMessage["content"][number],
+        { type: "text" }
+      > => {
+        return block.type === "text";
+      },
+    )
+    .map((block) => block.text)
+    .join("");
+}
+
+function shouldWriteHeadlessJsonEvent(event: AgentEvent): boolean {
+  switch (event.type) {
+    case "user_message":
+    case "assistant_message":
+    case "tool_result":
+    case "done":
+    case "error":
+    case "aborted":
+      return true;
+    default:
+      return false;
+  }
+}
+
+function createHeadlessOutputController(
+  state: AppState,
+  writeImpl: (text: string) => void,
+): HeadlessOutputController {
   let brokenPipe = false;
   let outputError: unknown = null;
+  const sigintHandler = createSigintHandler(state);
+
   const stopForBrokenPipe = (): void => {
     if (brokenPipe) {
       return;
@@ -90,51 +139,140 @@ export async function runHeadlessPrompt(
     brokenPipe = true;
     state.abortController?.abort();
   };
-  const writeLineImpl = options?.writeLine ?? defaultWriteLine;
-  const writeLine = (line: string): void => {
-    if (brokenPipe) {
+
+  const stdoutErrorHandler = (error: unknown): void => {
+    if (isBrokenPipeError(error)) {
+      stopForBrokenPipe();
       return;
     }
 
-    try {
-      writeLineImpl(line);
-    } catch (error) {
-      if (!isBrokenPipeError(error)) {
-        throw error;
+    outputError = error;
+    state.abortController?.abort();
+  };
+
+  return {
+    write(text) {
+      if (brokenPipe) {
+        return;
       }
-      stopForBrokenPipe();
-    }
+
+      try {
+        writeImpl(text);
+      } catch (error) {
+        if (!isBrokenPipeError(error)) {
+          throw error;
+        }
+        stopForBrokenPipe();
+      }
+    },
+    attach() {
+      process.stdout.on("error", stdoutErrorHandler);
+      process.on("SIGINT", sigintHandler);
+    },
+    detach() {
+      process.stdout.off("error", stdoutErrorHandler);
+      process.off("SIGINT", sigintHandler);
+    },
+    finalize(stopReason) {
+      if (outputError) {
+        throw outputError;
+      }
+      return brokenPipe ? "stop" : stopReason;
+    },
   };
+}
+
+/**
+ * Run a single headless prompt to completion and stream completed NDJSON events.
+ *
+ * The raw input is parsed with the same rules as interactive input. Slash
+ * commands are rejected in headless mode. Persisted messages and terminal
+ * events are written as one JSON object per line; streaming delta/progress
+ * events are omitted.
+ *
+ * @param state - Mutable application state for the run.
+ * @param rawInput - Exact raw prompt text supplied by the user.
+ * @param options - Optional event-output overrides.
+ * @returns The terminal stop reason for the agent loop.
+ */
+export async function runHeadlessPrompt(
+  state: AppState,
+  rawInput: string,
+  options?: HeadlessRunOptions,
+): Promise<HeadlessStopReason> {
+  const content = resolveHeadlessContent(state, rawInput);
+  const output = createHeadlessOutputController(
+    state,
+    options?.writeLine ?? ((line) => defaultWrite(`${line}\n`)),
+  );
   const hooks: SubmitTurnHooks = {
     onEvent: (event) => {
-      writeLine(JSON.stringify(event));
+      if (!shouldWriteHeadlessJsonEvent(event)) {
+        return;
+      }
+      output.write(JSON.stringify(event));
     },
   };
-  const sigintHandler = createSigintHandler(state);
-  const stdoutErrorHandler = (error: unknown): void => {
-    if (isBrokenPipeError(error)) {
-      stopForBrokenPipe();
-      return;
-    }
-    outputError = error;
-    state.abortController?.abort();
+
+  output.attach();
+  try {
+    const stopReason = await submitResolvedInput(
+      rawInput,
+      content,
+      state,
+      hooks,
+    );
+    return output.finalize(stopReason);
+  } finally {
+    output.detach();
+  }
+}
+
+/**
+ * Run a single headless prompt to completion and write only the final assistant text.
+ *
+ * The raw input is parsed with the same rules as interactive input. Slash
+ * commands are rejected in headless mode. Only the final persisted assistant
+ * message's text content is written to stdout.
+ *
+ * @param state - Mutable application state for the run.
+ * @param rawInput - Exact raw prompt text supplied by the user.
+ * @param options - Optional final-text output overrides.
+ * @returns The terminal stop reason for the agent loop.
+ */
+export async function runHeadlessPromptText(
+  state: AppState,
+  rawInput: string,
+  options?: HeadlessTextRunOptions,
+): Promise<HeadlessStopReason> {
+  const content = resolveHeadlessContent(state, rawInput);
+  const output = createHeadlessOutputController(
+    state,
+    options?.writeText ?? defaultWrite,
+  );
+  let finalAssistantMessage: AssistantMessage | null = null;
+  const hooks: SubmitTurnHooks = {
+    onEvent: (event) => {
+      if (event.type === "assistant_message") {
+        finalAssistantMessage = event.message;
+      }
+    },
   };
 
-  process.stdout.on("error", stdoutErrorHandler);
-  process.on("SIGINT", sigintHandler);
+  output.attach();
   try {
     const stopReason = await submitResolvedInput(
       rawInput,
-      resolved.content,
+      content,
       state,
       hooks,
     );
-    if (outputError) {
-      throw outputError;
+    const finalText = extractAssistantText(finalAssistantMessage);
+    if (finalText.length > 0) {
+      output.write(finalText);
     }
-    return brokenPipe ? "stop" : stopReason;
+    return output.finalize(stopReason);
   } finally {
-    process.stdout.off("error", stdoutErrorHandler);
-    process.off("SIGINT", sigintHandler);
+    output.detach();
   }
 }

package/src/index.ts

@@ -10,7 +10,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import type {
   KnownProvider,
@@ -19,14 +19,17 @@ import type {
   OAuthCredentials,
   ThinkingLevel,
   Tool,
+  UserMessage,
 } from "@mariozechner/pi-ai";
 import { getEnvApiKey, getModels, getProviders } from "@mariozechner/pi-ai";
 import { getOAuthApiKey, getOAuthProviders } from "@mariozechner/pi-ai/oauth";
 import type { ToolHandler } from "./agent.ts";
 import {
+  type CliOptions,
   parseCliArgs,
   resolveHeadlessPrompt,
   shouldUseHeadlessMode,
+  type TtyState,
 } from "./cli.ts";
 import { getErrorMessage } from "./errors.ts";
 import { type GitState, getGitState } from "./git.ts";
@@ -70,8 +73,12 @@ import {
   executeEdit,
   executeReadImage,
   executeShell,
+  executeTodoRead,
+  executeTodoWrite,
   readImageTool,
   shellTool,
+  todoReadTool,
+  todoWriteTool,
 } from "./tools.ts";
 import { resolveAppVersionLabel } from "./version.ts";
 
@@ -381,11 +388,28 @@ const BUILTIN_HANDLERS: Record<string, ToolHandler> = {
 function buildTools(
   model: Model<string>,
   plugins: LoadedPlugin[],
+  messages: AppState["messages"],
 ): { tools: Tool[]; toolHandlers: Map<string, ToolHandler> } {
-  const tools: Tool[] = [editTool, shellTool];
+  const tools: Tool[] = [editTool, shellTool, todoWriteTool, todoReadTool];
   const toolHandlers = new Map<string, ToolHandler>([
     [editTool.name, BUILTIN_HANDLERS.edit!],
     [shellTool.name, BUILTIN_HANDLERS.shell!],
+    [
+      todoWriteTool.name,
+      (args) =>
+        executeTodoWrite(
+          {
+            todos: Array.isArray(args.todos)
+              ? (args.todos as Array<{
+                  content: string;
+                  status: "pending" | "in_progress" | "completed" | "cancelled";
+                }>)
+              : [],
+          },
+          messages,
+        ),
+    ],
+    [todoReadTool.name, () => executeTodoRead(messages)],
   ]);
 
   // Conditionally register readImage for vision-capable models
@@ -541,8 +565,6 @@ export interface AppState {
   versionLabel: string;
   /** Current git state (null if not in a repo). */
   git: GitState | null;
-  /** Optional git state loader override used by tests. */
-  loadGitState?: (cwd: string) => Promise<GitState | null>;
   /** Available provider credentials (provider → API key). */
   providers: Map<string, string>;
   /** OAuth credentials on disk. */
@@ -561,6 +583,8 @@ export interface AppState {
   abortController: AbortController | null;
   /** Promise for the active conversational turn, used to serialize cleanup like `/undo`. */
   activeTurnPromise: Promise<void> | null;
+  /** Resolved user messages queued while the current run is still active. */
+  queuedUserMessages: UserMessage[];
   /** Whether to show thinking content. */
   showReasoning: boolean;
   /** Whether to show full (un-truncated) tool output. */
@@ -641,6 +665,7 @@ export async function init(): Promise<AppState> {
     running: false,
     abortController: null,
     activeTurnPromise: null,
+    queuedUserMessages: [],
     showReasoning: startup.showReasoning,
     verbose: startup.verbose,
     customModels: customResult.models,
@@ -648,16 +673,37 @@ export async function init(): Promise<AppState> {
   };
 }
 
+/** Resolve the shell label shown in the system prompt. */
+function resolvePromptShell(): string {
+  return basename(process.env.SHELL || "/bin/sh");
+}
+
+/** Resolve the normalized OS label shown in the system prompt. */
+function resolvePromptOs(): "linux" | "mac" | "docker" {
+  if (process.platform === "darwin") {
+    return "mac";
+  }
+  if (existsSync("/.dockerenv") || existsSync("/run/.containerenv")) {
+    return "docker";
+  }
+  return "linux";
+}
+
 /**
  * Build the system prompt for the current state.
  *
- * Separated from `init` because it's called on every turn (git state
- * may change between turns).
+ * Separated from `init` because turns still rebuild the assembled prompt
+ * from the session-stable prompt context plus the current runtime state.
  */
 export function buildPrompt(state: AppState): string {
   return buildSystemPrompt({
     cwd: state.cwd,
-    date: new Date().toISOString().slice(0, 10),
+    modelLabel: state.model
+      ? `${state.model.provider}/${state.model.id}`
+      : "unknown",
+    os: resolvePromptOs(),
+    shell: resolvePromptShell(),
+    supportsImages: state.model?.input.includes("image") ?? false,
     git: state.git,
     agentsMd: state.agentsMd,
     skills: state.skills,
@@ -673,7 +719,7 @@ export function buildToolList(state: AppState): {
   toolHandlers: Map<string, ToolHandler>;
 } {
   if (!state.model) return { tools: [], toolHandlers: new Map() };
-  return buildTools(state.model, state.plugins);
+  return buildTools(state.model, state.plugins, state.messages);
 }
 
 /**
@@ -740,6 +786,47 @@ export {
   saveOAuthCredentials,
 };
 
+// ---------------------------------------------------------------------------
+// Headless CLI
+// ---------------------------------------------------------------------------
+
+type HeadlessCliStopReason = "stop" | "length" | "error" | "aborted";
+
+/**
+ * Run one headless CLI prompt using the output mode selected by the parsed CLI flags.
+ *
+ * Non-TTY detection only decides whether headless mode should run at all.
+ * Once headless mode is selected, `--json` is the only switch that chooses
+ * NDJSON streaming versus final-text output.
+ *
+ * @param state - Initialized application state for the run.
+ * @param cli - Parsed CLI options.
+ * @param tty - Current TTY availability.
+ * @param deps - Injected I/O and runner callbacks.
+ * @returns The terminal stop reason for the headless run.
+ */
+export async function runHeadlessCli(
+  state: AppState,
+  cli: CliOptions,
+  tty: TtyState,
+  deps: {
+    readStdin: () => Promise<string>;
+    runJson: (
+      state: AppState,
+      rawPrompt: string,
+    ) => Promise<HeadlessCliStopReason>;
+    runText: (
+      state: AppState,
+      rawPrompt: string,
+    ) => Promise<HeadlessCliStopReason>;
+  },
+): Promise<HeadlessCliStopReason> {
+  const rawPrompt = await resolveHeadlessPrompt(cli, tty, deps.readStdin);
+  return cli.json
+    ? deps.runJson(state, rawPrompt)
+    : deps.runText(state, rawPrompt);
+}
+
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
@@ -762,11 +849,17 @@ export async function main(): Promise<void> {
 
   if (shouldUseHeadlessMode(cli, tty)) {
     try {
-      const rawPrompt = await resolveHeadlessPrompt(cli, tty, async () => {
-        return Bun.stdin.text();
+      const stopReason = await runHeadlessCli(state, cli, tty, {
+        readStdin: async () => Bun.stdin.text(),
+        runJson: async (headlessState, rawPrompt) => {
+          const { runHeadlessPrompt } = await import("./headless.ts");
+          return runHeadlessPrompt(headlessState, rawPrompt);
+        },
+        runText: async (headlessState, rawPrompt) => {
+          const { runHeadlessPromptText } = await import("./headless.ts");
+          return runHeadlessPromptText(headlessState, rawPrompt);
+        },
       });
-      const { runHeadlessPrompt } = await import("./headless.ts");
-      const stopReason = await runHeadlessPrompt(state, rawPrompt);
       if (stopReason === "aborted") {
         process.exitCode = 130;
       } else if (stopReason === "error") {

package/src/input.ts

@@ -24,6 +24,7 @@ export const COMMANDS = [
   "undo",
   "reasoning",
   "verbose",
+  "todo",
   "login",
   "logout",
   "help",