mini-coder 0.8.0 → 0.8.1

package/README.md

@@ -21,8 +21,8 @@ if set). There is no project-local config and no override flags.
 
 ```json
 {
-  "provider": "anthropic",
-  "model": "claude-sonnet-4-5"
+  "provider": "opencode-go",
+  "model": "deepseek-v4.1-flash"
 }
 ```
 
@@ -41,7 +41,7 @@ Only `provider` and `model` are required. Defaults for the rest:
 ```
 
 - `provider` / `model` — any model from the `pi-ai` catalog. Invalid pairs fail with a
-  list of available models for that provider.
+  list of available models for that provider. Requires a discoverable api key from the environment (Like: OPENCODE_API_KEY).
 - `sessionsDir` — where append-only session JSONL files are written. (no relative paths for now, absolute paths only).
 - `systemPrompt` — the base of the system prompt. Skills and agent files, if
   enabled, are appended after it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-coder",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "A fast, transparent, config-first terminal coding agent",
   "type": "module",
   "license": "MIT",

package/src/agent.ts

@@ -12,6 +12,7 @@ import {
   type UserMessage,
 } from "@earendil-works/pi-ai";
 import type { Session } from "./session.ts";
+import type { ToolName } from "./config.ts";
 import { acceptsImages, executeTool, type ToolDetails, type ToolResult } from "./tools/index.ts";
 
 export type Phase = "preparing" | "waitingModel" | "streaming" | "runningTool" | "pausing" | "idle";
@@ -47,6 +48,8 @@ export interface AgentOptions {
   model: Model<Api>;
   systemPrompt: string;
   tools: Tool[];
+  /** The configured tool names, kept so a model switch can rebuild `tools`. */
+  toolNames: ToolName[];
   thinkingEffort: ModelThinkingLevel;
   session: Session;
 }
@@ -58,9 +61,20 @@ interface AgentRun extends AgentOptions {
   onEvent: (event: AgentEvent) => void;
 }
 
+/** The concatenated text blocks of an assistant message, ignoring the rest. */
+export function assistantText(message: AssistantMessage): string {
+  return message.content
+    .filter((block) => block.type === "text")
+    .map((block) => block.text)
+    .join("");
+}
+
 export async function runAgentTurn(run: AgentRun): Promise<void> {
   const { messages, session, signal, interaction, onEvent } = run;
 
+  const cancelled = (): void => onEvent({ type: "cancelled" });
+  const failed = (message: string): void => onEvent({ type: "error", message });
+
   /** Appends a user message the model reads at the next step boundary. */
   const steer = (content: string): void => {
     if (content === "") return;
@@ -91,7 +105,7 @@ export async function runAgentTurn(run: AgentRun): Promise<void> {
   for (;;) {
     const steering = await pauseStep();
     if (steering === null) {
-      onEvent({ type: "cancelled" });
+      cancelled();
       return;
     }
     steer(steering);
@@ -116,7 +130,7 @@ export async function runAgentTurn(run: AgentRun): Promise<void> {
         sessionId: session.id ?? undefined,
       });
     } catch (error) {
-      onEvent({ type: "error", message: (error as Error).message });
+      failed((error as Error).message);
       return;
     }
 
@@ -138,7 +152,7 @@ export async function runAgentTurn(run: AgentRun): Promise<void> {
         }
       }
     } catch (error) {
-      onEvent({ type: "error", message: (error as Error).message });
+      failed((error as Error).message);
       return;
     }
 
@@ -148,11 +162,11 @@ export async function runAgentTurn(run: AgentRun): Promise<void> {
     onEvent({ type: "message", message: assistant });
 
     if (assistant.stopReason === "aborted") {
-      onEvent({ type: "cancelled" });
+      cancelled();
       return;
     }
     if (assistant.stopReason === "error") {
-      onEvent({ type: "error", message: assistant.errorMessage ?? "provider error" });
+      failed(assistant.errorMessage ?? "provider error");
       return;
     }
 
@@ -169,7 +183,7 @@ export async function runAgentTurn(run: AgentRun): Promise<void> {
     for (const call of toolCalls) {
       const steering = await pauseStep();
       if (steering === null) {
-        onEvent({ type: "cancelled" });
+        cancelled();
         return;
       }
       if (steering !== "") held.push(steering);

package/src/auth.ts

@@ -0,0 +1,84 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { AuthOperationOptions, Credential, CredentialInfo, CredentialStore } from "@earendil-works/pi-ai";
+
+/** The `auth.json` layout: one credential per provider id. */
+type AuthFile = Record<string, Credential>;
+
+function readFile(path: string): AuthFile {
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as AuthFile;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+/** Write the whole file atomically: temp file, then rename over the target. */
+function writeFile(path: string, data: AuthFile): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = join(dirname(path), `.${process.pid}.${Date.now()}.tmp`);
+  writeFileSync(temp, `${JSON.stringify(data, null, 2)}\n`);
+  renameSync(temp, path);
+}
+
+/**
+ * File-backed `CredentialStore` over `auth.json`. Writes are serialized per
+ * provider through an in-process promise chain, so `modify` and `delete` on
+ * the same provider never interleave.
+ */
+export function createCredentialStore(path: string): CredentialStore {
+  const chains = new Map<string, Promise<unknown>>();
+
+  function enqueue<T>(providerId: string, task: () => Promise<T>, options?: AuthOperationOptions): Promise<T> {
+    options?.signal?.throwIfAborted();
+    const previous = chains.get(providerId) ?? Promise.resolve();
+    const queued = (async () => {
+      await previous.catch(() => {});
+      options?.signal?.throwIfAborted();
+      return await task();
+    })();
+    const tail = queued.catch(() => {});
+    chains.set(providerId, tail);
+    void tail.then(() => {
+      if (chains.get(providerId) === tail) chains.delete(providerId);
+    });
+    return queued;
+  }
+
+  return {
+    async read(providerId, options): Promise<Credential | undefined> {
+      options?.signal?.throwIfAborted();
+      return readFile(path)[providerId];
+    },
+    async list(options): Promise<readonly CredentialInfo[]> {
+      options?.signal?.throwIfAborted();
+      return Object.entries(readFile(path)).map(([providerId, credential]) => ({ providerId, type: credential.type }));
+    },
+    modify(providerId, fn, options): Promise<Credential | undefined> {
+      return enqueue(
+        providerId,
+        async () => {
+          const data = readFile(path);
+          const next = await fn(data[providerId]);
+          options?.signal?.throwIfAborted();
+          if (next !== undefined) data[providerId] = next;
+          writeFile(path, data);
+          return next ?? data[providerId];
+        },
+        options,
+      );
+    },
+    delete(providerId, options): Promise<void> {
+      return enqueue(
+        providerId,
+        async () => {
+          const data = readFile(path);
+          delete data[providerId];
+          writeFile(path, data);
+        },
+        options,
+      );
+    },
+  };
+}

package/src/cli.ts

@@ -4,7 +4,7 @@ import { loadConfig, resolveModel } from "./config.ts";
 import { buildSystemPrompt } from "./prompt.ts";
 import { acceptsImages, toolSchemas } from "./tools/index.ts";
 import { Session } from "./session.ts";
-import { NO_INTERACTION, runAgentTurn, type AgentOptions } from "./agent.ts";
+import { NO_INTERACTION, assistantText, runAgentTurn, type AgentOptions } from "./agent.ts";
 import { runTui } from "./tui/tui.ts";
 
 function parseArgs(argv: string[]): { print: string | null } {
@@ -61,10 +61,7 @@ async function runPrint(prompt: string, ctx: AgentOptions): Promise<number> {
 
   const last = messages.filter((message): message is AssistantMessage => message.role === "assistant").at(-1);
   if (!failed && !cancelled && last !== undefined) {
-    const text = last.content
-      .filter((block) => block.type === "text")
-      .map((block) => block.text)
-      .join("");
+    const text = assistantText(last);
     if (text !== "") process.stdout.write(text.endsWith("\n") ? text : `${text}\n`);
   }
   return failed || cancelled ? 1 : 0;
@@ -80,6 +77,7 @@ async function main(): Promise<void> {
     model,
     systemPrompt: buildSystemPrompt(config),
     tools: toolSchemas(config.tools, acceptsImages(model)),
+    toolNames: config.tools,
     thinkingEffort: clampThinkingLevel(model, config.thinkingEffort),
     session,
   };

package/src/config.ts

@@ -1,12 +1,13 @@
-import { readFileSync } from "node:fs";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import {
   createProvider,
   envApiKeyAuth,
   Type,
   type Api,
   type Model,
+  type ModelThinkingLevel,
   type MutableModels,
   type Static,
 } from "@earendil-works/pi-ai";
@@ -16,6 +17,7 @@ import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messag
 import { googleGenerativeAIApi } from "@earendil-works/pi-ai/api/google-generative-ai.lazy";
 import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
 import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import { createCredentialStore } from "./auth.ts";
 
 const ToolNameSchema = Type.Union([Type.Literal("edit"), Type.Literal("read"), Type.Literal("bash")]);
 export type ToolName = Static<typeof ToolNameSchema>;
@@ -44,6 +46,7 @@ const CustomProviderSchema = Type.Object(
 const ConfigSchema = Type.Object(
   {
     sessionsDir: Type.String({ default: join(process.cwd(), "sessions") }),
+    authFile: Type.String({ default: join(configDir(), "auth.json") }),
     systemPrompt: Type.String({ default: "" }),
     discoverAgentFiles: Type.Boolean({ default: true }),
     skillsDirs: Type.Array(Type.String(), { default: [] }),
@@ -52,6 +55,7 @@ const ConfigSchema = Type.Object(
     model: Type.String(),
     thinkingEffort: Type.Union(
       [
+        Type.Literal("off"),
         Type.Literal("minimal"),
         Type.Literal("low"),
         Type.Literal("medium"),
@@ -67,9 +71,13 @@ const ConfigSchema = Type.Object(
 );
 export type Config = Static<typeof ConfigSchema>;
 
-function configPath(): string {
+function configDir(): string {
   const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-  return join(base, "mini-coder", "config.json");
+  return join(base, "mini-coder");
+}
+
+function configPath(): string {
+  return join(configDir(), "config.json");
 }
 
 function readJson(path: string): unknown {
@@ -98,6 +106,27 @@ export function loadConfig(): Config {
   }
 }
 
+/**
+ * Persist a patch to the global config, leaving every other key untouched.
+ * Written atomically: a temp file, then a rename over the target.
+ */
+export function saveConfig(patch: {
+  provider?: string;
+  model?: string;
+  thinkingEffort?: ModelThinkingLevel;
+}): void {
+  const path = configPath();
+  const existing = readJson(path);
+  if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+    throw new Error(`config ${path}: not an object`);
+  }
+  const next = { ...existing, ...patch };
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = join(dirname(path), `.${process.pid}.${Date.now()}.tmp`);
+  writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`);
+  renameSync(temp, path);
+}
+
 const API_FACTORY: Record<CustomApi, () => ReturnType<typeof openAICompletionsApi>> = {
   "openai-completions": openAICompletionsApi,
   "openai-responses": openAIResponsesApi,
@@ -106,7 +135,7 @@ const API_FACTORY: Record<CustomApi, () => ReturnType<typeof openAICompletionsAp
 };
 
 export function resolveModel(config: Config): { models: MutableModels; model: Model<Api> } {
-  const models = builtinModels();
+  const models = builtinModels({ credentials: createCredentialStore(config.authFile) });
   for (const provider of config.customProviders) {
     const name = provider.name ?? provider.id;
     models.setProvider(

package/src/tools/bash.ts

@@ -61,20 +61,17 @@ export function bash(args: BashArgs, ctx: ToolContext): Promise<ToolResult> {
     };
 
     let killTimer: NodeJS.Timeout | undefined;
-    const onAbort = () => {
-      if (!child.pid) return;
+    const kill = (signal: NodeJS.Signals): void => {
       try {
-        process.kill(-child.pid, "SIGTERM");
+        process.kill(-child.pid!, signal);
       } catch {
         /* already gone */
       }
-      killTimer = setTimeout(() => {
-        try {
-          process.kill(-child.pid!, "SIGKILL");
-        } catch {
-          /* already gone */
-        }
-      }, 300);
+    };
+    const onAbort = () => {
+      if (!child.pid) return;
+      kill("SIGTERM");
+      killTimer = setTimeout(() => kill("SIGKILL"), 300);
     };
 
     if (ctx.signal.aborted) onAbort();

package/src/tui/commands.ts

@@ -1,14 +1,40 @@
-import { dim } from "./styles.ts";
+import {
+  getSupportedThinkingLevels,
+  type Api,
+  type AuthEvent,
+  type AuthPrompt,
+  type AuthType,
+  type Model,
+  type ModelThinkingLevel,
+  type Models,
+} from "@earendil-works/pi-ai";
+import { saveConfig } from "../config.ts";
+import { dim, red } from "./styles.ts";
+import { commonPrefix } from "./complete.ts";
 
 export interface CommandContext {
+  /** The collection the running command may reach, e.g. to start a login. */
+  models: Models;
+  /** The model the session is currently running. */
+  model: Model<Api>;
+  /** Switches the running session to `model`. */
+  select(model: Model<Api>): void;
+  /** Sets the running session's thinking level. */
+  setThinking(level: ModelThinkingLevel): void;
+  /** Aborts when the running command is cancelled (Ctrl+C). */
+  signal: AbortSignal;
   /** Appends already-styled lines to scrollback. */
   write(lines: string[]): void;
+  /** Asks the user a question and resolves with the next submitted line. */
+  prompt(prompt: AuthPrompt): Promise<string>;
+  /** Reports a login event as styled scrollback lines. */
+  notify(event: AuthEvent): void;
 }
 
-interface Command {
+export interface Command {
   name: string; // no leading slash, lowercase
   description: string; // one line, shown by /help
-  run(ctx: CommandContext, args: string): void;
+  run(ctx: CommandContext, args: string): void | Promise<void>;
 }
 
 /** The keybindings the TUI accepts, in the order `/help` prints them. */
@@ -18,6 +44,7 @@ const KEYBINDINGS: [string, string][] = [
   ["Esc", "pause the turn at the next step boundary"],
   ["Ctrl+C", "cancel the turn"],
   ["Ctrl+D", "exit on an empty draft"],
+  ["Tab", "complete command or path"],
 ];
 
 /** One aligned `key  description` block; the key column is dimmed. */
@@ -35,9 +62,123 @@ const help: Command = {
   },
 };
 
-const COMMANDS: Command[] = [help];
+const login: Command = {
+  name: "login",
+  description: "authenticate a provider",
+  async run(ctx, args): Promise<void> {
+    const providers = ctx.models
+      .getProviders()
+      .filter((provider) => provider.auth.oauth?.login !== undefined || provider.auth.apiKey?.login !== undefined);
+    const providerId =
+      args.trim() ||
+      (await ctx.prompt({
+        type: "select",
+        message: "Select a provider",
+        options: providers.map((provider) => ({ id: provider.id, label: provider.name })),
+      }));
+    const provider = ctx.models.getProvider(providerId);
+    if (provider === undefined) throw new Error(`unknown provider: ${providerId}`);
 
-/** `/name args` for a known `name`, else null; unknown slash text stays a message. */
+    const oauth = provider.auth.oauth;
+    const apiKey = provider.auth.apiKey;
+    const types: { id: AuthType; label: string }[] = [];
+    if (oauth?.login !== undefined) {
+      types.push({ id: "oauth", label: oauth.loginLabel ?? oauth.name });
+    }
+    if (apiKey?.login !== undefined) types.push({ id: "api_key", label: apiKey.name });
+    if (types.length === 0) throw new Error(`provider "${providerId}" has no login flow`);
+    const type =
+      types.length === 1
+        ? types[0].id
+        : ((await ctx.prompt({
+            type: "select",
+            message: `How would you like to authenticate with ${provider.name}?`,
+            options: types,
+          })) as AuthType);
+
+    try {
+      await ctx.models.login(providerId, type, {
+        signal: ctx.signal,
+        prompt: (prompt) => ctx.prompt(prompt),
+        notify: (event) => ctx.notify(event),
+      });
+    } catch (error) {
+      if (ctx.signal.aborted) {
+        ctx.write([red("! cancelled")]);
+        return;
+      }
+      throw error;
+    }
+    const source = (await ctx.models.getAuth(providerId))?.source;
+    ctx.write([`logged in to ${provider.name}${source === undefined ? "" : ` (${source})`}`]);
+  },
+};
+
+const provider: Command = {
+  name: "provider",
+  description: "choose the provider and model",
+  async run(ctx): Promise<void> {
+    const available = await ctx.models.getAvailable(undefined, { signal: ctx.signal });
+    const ids = [...new Set(available.map((m) => m.provider))];
+    if (ids.length === 0) throw new Error("no authenticated providers");
+    const providerId = await ctx.prompt({
+      type: "select",
+      message: "Select a provider",
+      options: ids.map((id) => ({ id, label: ctx.models.getProvider(id)?.name ?? id })),
+    });
+    const models = available.filter((m) => m.provider === providerId);
+    if (models.length === 0) throw new Error(`no models for provider "${providerId}"`);
+    const name = ctx.models.getProvider(providerId)?.name ?? providerId;
+    const modelId = await ctx.prompt({
+      type: "select",
+      message: `Select a model for ${name}`,
+      options: models.map((m) => ({ id: m.id, label: m.name ?? m.id })),
+    });
+    const chosen = models.find((m) => m.id === modelId);
+    if (chosen === undefined) throw new Error(`unknown model: ${modelId}`);
+    saveConfig({ provider: providerId, model: modelId });
+    ctx.select(chosen);
+  },
+};
+
+const thinking: Command = {
+  name: "thinking",
+  description: "set the thinking level",
+  async run(ctx): Promise<void> {
+    const levels = getSupportedThinkingLevels(ctx.model);
+    const level = (await ctx.prompt({
+      type: "select",
+      message: "Select a thinking level",
+      options: levels.map((l) => ({ id: l, label: l })),
+    })) as ModelThinkingLevel;
+    saveConfig({ thinkingEffort: level });
+    ctx.setThinking(level);
+  },
+};
+
+const model: Command = {
+  name: "model",
+  description: "choose a model for the current provider",
+  async run(ctx): Promise<void> {
+    const providerId = ctx.model.provider;
+    const models = await ctx.models.getAvailable(providerId, { signal: ctx.signal });
+    if (models.length === 0) throw new Error(`no models for provider "${providerId}"`);
+    const name = ctx.models.getProvider(providerId)?.name ?? providerId;
+    const modelId = await ctx.prompt({
+      type: "select",
+      message: `Select a model for ${name}`,
+      options: models.map((m) => ({ id: m.id, label: m.name ?? m.id })),
+    });
+    const chosen = models.find((m) => m.id === modelId);
+    if (chosen === undefined) throw new Error(`unknown model: ${modelId}`);
+    saveConfig({ provider: providerId, model: modelId });
+    ctx.select(chosen);
+  },
+};
+
+const COMMANDS: Command[] = [help, login, provider, model, thinking];
+
+/** `/name` 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;
@@ -56,8 +197,3 @@ export function completeCommand(draft: string): string | null {
   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/complete.ts

@@ -0,0 +1,85 @@
+import { readdirSync, statSync, type Dirent } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+/**
+ * Deliberately bash-unfaithful: no `cdable_vars`, no `~user` expansion (`~`
+ * always means `homedir()`), no `$VAR`, backtick, or history expansion (word
+ * text is always literal), and no shell options — dotfile hiding, byte-exact
+ * matching, and dir-slash behavior below hold unconditionally.
+ */
+
+/**
+ * A word must already carry path syntax to be completed: a leading `~`, a
+ * leading `./` or `../` (or bare `.` / `..`), a leading `/`, or any segment
+ * followed by a slash somewhere in the word. Bare words (`re`, `hello`) return
+ * null without a syscall, so mid-sentence prose never gets hijacked.
+ */
+const PATH_LIKE = /^(?:~|\/|\.{1,2}(?:\/|$)|\w+\/)/;
+
+/** A directory, or a symlink that resolves to one (`statSync` follows). */
+function isDir(path: string, entry: Dirent): boolean {
+  if (entry.isDirectory()) return true;
+  if (!entry.isSymbolicLink()) return false;
+  try {
+    return statSync(join(path, entry.name)).isDirectory();
+  } catch {
+    return false; // broken link completes file-shaped, like bash.
+  }
+}
+
+/**
+ * Completes `word` as a file path, bash-readline-style: the returned word is
+ * the whole feedback, a strict extension of what was typed. Unreadable
+ * locations, paths through files, and nothing longer to add all give null and
+ * the caller leaves the draft alone.
+ */
+export function completePath(word: string, cwd: string): string | null {
+  if (!PATH_LIKE.test(word)) return null;
+
+  // Word = dirPart + prefix, split at the last slash, slash kept with dirPart.
+  const slash = word.lastIndexOf("/");
+  const prefix = word.slice(slash + 1);
+
+  // Resolve dirPart to the directory to list. `~` means homedir() here and
+  // nowhere else: the returned word below reuses the user's shorthand verbatim
+  // (`~/Doc⇥` stays `~/Documents/`), so this resolve only locates the listing.
+  // Concatenate before resolving — `resolve(home, "/x")` would reset to root.
+  let dir: string;
+  if (word.startsWith("~")) dir = resolve(homedir() + word.slice(1, slash));
+  else if (slash === 0) dir = "/";
+  else dir = resolve(cwd, word.slice(0, slash));
+
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null; // vanished, permission, or a file in the path: nothing better.
+  }
+
+  // Bash hides dotfiles unless the prefix itself starts with one (`~/.⇥`
+  // includes hidden entries). A directory completion grows a trailing `/` so
+  // the next Tab descends into it; a symlink to a directory counts as one —
+  // `withFileTypes` reports the link itself, so the target needs one stat.
+  const candidates = entries
+    .filter((entry) => entry.name.startsWith(prefix) && (prefix.startsWith(".") || !entry.name.startsWith(".")))
+    .map((entry) => (isDir(dir, entry) ? `${entry.name}/` : entry.name));
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) {
+    // Worth returning only when it adds something the user did not already
+    // type (`renameTag` typed against the single file match `renameTag` → null).
+    return candidates[0] === prefix ? null : word.slice(0, word.length - prefix.length) + candidates[0];
+  }
+  const shared = candidates.reduce(commonPrefix);
+  // Recombine over the untouched dirPart, so `~/Doc⇥` becomes `~/Documents/`
+  // and never `/home/xonecas/Documents/`; no exact-name short-circuit here.
+  return shared.length > prefix.length ? word.slice(0, word.length - prefix.length) + shared : null;
+}
+
+/** Case-sensitive longest common prefix; commands.ts uses it for command
+ *  completion, completePath for path candidates. */
+export 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

@@ -39,11 +39,21 @@ export class Editor {
   private col = 0;
   private scroll = 0;
   private width = DEFAULT_WIDTH;
+  private masked = false;
 
   text(): string {
     return this.lines.join("\n");
   }
 
+  /** Renders each character as `*` without changing the underlying text. */
+  setMasked(masked: boolean): void {
+    this.masked = masked;
+  }
+
+  private display(line: string): string {
+    return this.masked ? "*".repeat(codePoints(line).length) : line;
+  }
+
   clear(): void {
     this.lines = [""];
     this.row = 0;
@@ -121,7 +131,7 @@ export class Editor {
     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);
+      const chunks = wrapLine(expandTabs(this.display(this.lines[line]), TAB), this.width);
       if (line === this.row) {
         const caret = this.caret();
         cursorRow = rows.length + caret.row;
@@ -142,7 +152,7 @@ export class Editor {
 
   /** 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 line = this.display(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);
@@ -288,4 +298,23 @@ export class Editor {
     this.lines[this.row] = current.slice(0, start).join("") + current.slice(this.col).join("");
     this.col = start;
   }
+
+  /**
+   * Applies `step` to the word ending at the caret, replacing it; false when
+   * there is no word before the caret. Whitespace is `isSpace` (Unicode `\s`),
+   * so a path word may carry `/`, `~`, `.`, `$` — no path-specific separator
+   * set. No completion-undo: bash's TAB-_ restore is out; the user backspaces
+   * or re-types instead, with Esc and the editor's own keys as recovery.
+   */
+  completeWord(step: (word: string) => string | null): boolean {
+    const current = codePoints(this.lines[this.row]);
+    const start = wordStart(current, this.col);
+    if (start === this.col || isSpace(current[this.col - 1])) return false;
+    const word = current.slice(start, this.col).join("");
+    const completed = step(word);
+    if (completed === null) return false;
+    this.lines[this.row] = current.slice(0, start).join("") + completed + current.slice(this.col).join("");
+    this.col = start + codePoints(completed).length;
+    return true;
+  }
 }

package/src/tui/styles.ts

@@ -5,38 +5,16 @@ import { NORMAL_FG, PALETTE, sgrFg } from "./theme.ts";
  * re-asserting `Normal`'s, never by resetting: the row's background, set by the
  * renderer, must survive, and no cell may fall back to the terminal's colours.
  */
-function foreground(text: string, hex: string): string {
-  return `${sgrFg(hex)}${text}${sgrFg(NORMAL_FG)}`;
-}
+const fg = (hex: string) => (text: string): string => `${sgrFg(hex)}${text}${sgrFg(NORMAL_FG)}`;
 
 /** `Comment`, the colour diff context lines share. */
-export function dim(text: string): string {
-  return foreground(text, PALETTE.comment);
-}
-
-export function red(text: string): string {
-  return foreground(text, PALETTE.red);
-}
-
-export function green(text: string): string {
-  return foreground(text, PALETTE.green);
-}
-
-export function yellow(text: string): string {
-  return foreground(text, PALETTE.yellow);
-}
-
+export const dim = fg(PALETTE.comment);
+export const red = fg(PALETTE.red);
+export const green = fg(PALETTE.green);
+export const yellow = fg(PALETTE.yellow);
 /** Diff hunk headers; the palette's `blue` sits closest to the old ANSI cyan. */
-export function cyan(text: string): string {
-  return foreground(text, PALETTE.blue);
-}
-
+export const cyan = fg(PALETTE.blue);
 /** The user's own words; also `Function`, which user rows never collide with. */
-export function blue(text: string): string {
-  return foreground(text, PALETTE.blue);
-}
-
+export const blue = fg(PALETTE.blue);
 /** The tool accent: call-line heads. */
-export function teal(text: string): string {
-  return foreground(text, PALETTE.teal);
-}
+export const teal = fg(PALETTE.teal);

package/src/tui/theme.ts

@@ -78,7 +78,6 @@ export const STYLES: Record<string, Style | undefined> = {
   escape: { fg: PALETTE.magenta },
   function: { fg: PALETTE.blue },
   "function.builtin": { fg: PALETTE.blue1 },
-  "function.method": { fg: PALETTE.blue },
   keyword: { fg: PALETTE.purple },
   number: { fg: PALETTE.orange },
   operator: { fg: PALETTE.blue5 },

package/src/tui/tui.ts

@@ -1,9 +1,22 @@
 import process from "node:process";
-import type { AssistantMessage, JsonObject, Message, UserMessage } from "@earendil-works/pi-ai";
-import { runAgentTurn, type AgentEvent, type AgentOptions, type Phase } from "../agent.ts";
+import {
+  clampThinkingLevel,
+  type Api,
+  type AssistantMessage,
+  type AuthEvent,
+  type AuthPrompt,
+  type JsonObject,
+  type Message,
+  type Model,
+  type ModelThinkingLevel,
+  type UserMessage,
+} from "@earendil-works/pi-ai";
+import { assistantText, runAgentTurn, type AgentEvent, type AgentOptions, type Phase } from "../agent.ts";
+import { acceptsImages, toolSchemas } from "../tools/index.ts";
 import { Terminal, expandTabs, sanitize, wrapLine, type Key } from "./term.ts";
 import { Editor } from "./editor.ts";
-import { completeCommand, findCommand, type CommandContext } from "./commands.ts";
+import { completeCommand, findCommand, type Command, type CommandContext } from "./commands.ts";
+import { completePath } from "./complete.ts";
 import { MarkdownStream, TailStream, type BodyLine, type StreamRenderer } from "./stream.ts";
 import { blue, cyan, dim, green, red, teal } from "./styles.ts";
 import { DIFF_ADD, DIFF_DELETE, NORMAL_BG, sgrBg, sgrPlain } from "./theme.ts";
@@ -176,14 +189,13 @@ class Tui {
   private readonly messages: Message[] = [];
   readonly done: Promise<void>;
 
-  /** The only capability a command gets: styled lines into scrollback. */
-  private readonly commandContext: CommandContext = {
-    write: (lines) => {
-      this.separator = true;
-      this.commitLines(lines.map((text) => ({ text })));
-      this.separator = true;
-    },
-  };
+  /** A running command's cancellation, and its one pending prompt. */
+  private commandAbort: AbortController | null = null;
+  private pendingPrompt: {
+    prompt: AuthPrompt;
+    resolve: (value: string) => void;
+    reject: (error: Error) => void;
+  } | null = null;
 
   private resolveExit: () => void = () => {};
   private phase: Phase = "idle";
@@ -230,9 +242,7 @@ class Tui {
     this.term.start();
     process.on("SIGINT", this.onSignal);
     process.on("SIGTERM", this.onSignal);
-    this.separator = true;
-    this.push(`mini-coder · ${this.opts.model.provider}/${this.opts.model.id} · ${this.opts.thinkingEffort}`);
-    this.separator = true;
+    this.pushBanner();
     this.render();
   }
 
@@ -240,11 +250,12 @@ class Tui {
 
   private handleKey(key: Key): void {
     if (key.type === "eof") {
-      if (!this.active && this.editor.text() === "") this.exit();
+      if (!this.active && this.commandAbort === null && this.editor.text() === "") this.exit();
       return;
     }
     if (key.type === "interrupt") {
       if (this.active) this.cancel();
+      else if (this.commandAbort !== null) this.commandAbort.abort();
       else if (this.editor.text() !== "") {
         this.editor.clear();
         this.render();
@@ -262,8 +273,10 @@ class Tui {
       const completed = completeCommand(this.editor.text());
       if (completed !== null) {
         this.editor.setText(completed);
-        this.render();
+      } else {
+        this.editor.completeWord((word) => completePath(word, process.cwd()));
       }
+      this.render();
       return;
     }
     const result = this.editor.handle(key);
@@ -281,11 +294,18 @@ class Tui {
       }
       return;
     }
+    if (this.pendingPrompt !== null) {
+      this.editor.clear();
+      this.render();
+      this.answerPrompt(text);
+      return;
+    }
+    if (this.commandAbort !== null) return;
     if (text.trim() === "") return;
-    const invocation = findCommand(text);
-    if (invocation !== null) {
+    const found = findCommand(text);
+    if (found !== null) {
       this.editor.clear();
-      invocation.command.run(this.commandContext, invocation.args);
+      this.runCommand(found.command, found.args);
       this.render();
       return;
     }
@@ -297,6 +317,152 @@ class Tui {
     this.startTurn();
   }
 
+  /**
+   * Runs one command with a fresh context. Lines submitted while it runs route
+   * to a pending prompt; Ctrl+C aborts its signal. No agent turn may start
+   * until it settles. Errors surface as an error line.
+   */
+  private runCommand(command: Command, args: string): void {
+    const abort = new AbortController();
+    this.commandAbort = abort;
+    const ctx: CommandContext = {
+      models: this.opts.models,
+      model: this.opts.model,
+      select: (model) => this.select(model),
+      setThinking: (level) => this.setThinking(level),
+      signal: abort.signal,
+      write: (lines) => {
+        this.separator = true;
+        this.commitLines(lines.map((text) => ({ text })));
+        this.separator = true;
+      },
+      prompt: (prompt) => this.ask(prompt),
+      notify: (event) => this.notify(event),
+    };
+    void (async () => {
+      try {
+        await command.run(ctx, args);
+      } catch (error) {
+        this.separator = true;
+        this.push(red(`! ${(error as Error).message}`));
+        this.separator = true;
+      } finally {
+        this.commandAbort = null;
+        this.pendingPrompt = null;
+        this.editor.setMasked(false);
+        this.render();
+      }
+    })();
+  }
+
+  /** The startup and selection banner: provider, model, and thinking effort. */
+  private pushBanner(): void {
+    this.separator = true;
+    this.push(`mini-coder · ${this.opts.model.provider}/${this.opts.model.id} · ${this.opts.thinkingEffort}`);
+    this.separator = true;
+  }
+
+  /**
+   * Switches the running session to `model`: derived state follows — the
+   * thinking effort is re-clamped, and `read`'s image behaviour is rebuilt for
+   * the new model. The status line and context readout read `opts.model`, so
+   * they update on the next render.
+   */
+  private select(model: Model<Api>): void {
+    this.opts.model = model;
+    this.opts.thinkingEffort = clampThinkingLevel(model, this.opts.thinkingEffort);
+    this.opts.tools = toolSchemas(this.opts.toolNames, acceptsImages(model));
+    this.pushBanner();
+    this.render();
+  }
+
+  /** Sets the running session's thinking level, clamped to the current model. */
+  private setThinking(level: ModelThinkingLevel): void {
+    this.opts.thinkingEffort = clampThinkingLevel(this.opts.model, level);
+    this.pushBanner();
+    this.render();
+  }
+
+  /** Commits a prompt and returns a promise resolving with the next submitted line. */
+  private ask(prompt: AuthPrompt): Promise<string> {
+    if (this.pendingPrompt !== null) return Promise.reject(new Error("a prompt is already pending"));
+    this.separator = true;
+    this.push(prompt.message);
+    if (prompt.type === "select") {
+      for (let i = 0; i < prompt.options.length; i++) this.push(`  ${i + 1}. ${prompt.options[i].label}`);
+    } else if (prompt.placeholder !== undefined) {
+      this.push(`  (${prompt.placeholder})`);
+    }
+    this.separator = true;
+    this.editor.setMasked(prompt.type === "secret");
+    this.render();
+
+    return new Promise<string>((resolve, reject) => {
+      const flow = this.commandAbort?.signal;
+      const onAbort = (): void => {
+        settle(() => reject(new Error("cancelled")));
+      };
+      const settle = (fn: () => void): void => {
+        prompt.signal?.removeEventListener("abort", onAbort);
+        flow?.removeEventListener("abort", onAbort);
+        this.editor.setMasked(false);
+        this.pendingPrompt = null;
+        this.render();
+        fn();
+      };
+      if (prompt.signal?.aborted === true || flow?.aborted === true) {
+        onAbort();
+        return;
+      }
+      prompt.signal?.addEventListener("abort", onAbort);
+      flow?.addEventListener("abort", onAbort);
+      this.pendingPrompt = {
+        prompt,
+        resolve: (value) => settle(() => resolve(value)),
+        reject: (error) => settle(() => reject(error)),
+      };
+    });
+  }
+
+  /** Turns the submitted line into the answer: a `select` maps to its option id. */
+  private answerPrompt(text: string): void {
+    const pending = this.pendingPrompt;
+    if (pending === null) return;
+    if (pending.prompt.type !== "select") {
+      pending.resolve(text);
+      return;
+    }
+    const trimmed = text.trim();
+    const index = Number.parseInt(trimmed, 10);
+    const byIndex = String(index) === trimmed ? pending.prompt.options[index - 1] : undefined;
+    const chosen = byIndex ?? pending.prompt.options.find((option) => option.id === trimmed || option.label === trimmed);
+    if (chosen === undefined) pending.reject(new Error(`invalid selection: ${trimmed}`));
+    else pending.resolve(chosen.id);
+  }
+
+  private notify(event: AuthEvent): void {
+    this.separator = true;
+    switch (event.type) {
+      case "info":
+        this.push(event.message);
+        for (const link of event.links ?? []) this.push(link.label === undefined ? link.url : `${link.label}: ${link.url}`);
+        break;
+      case "auth_url":
+        this.push(event.url);
+        if (event.instructions !== undefined) this.push(event.instructions);
+        break;
+      case "device_code":
+        this.push(event.verificationUri);
+        this.push(`code: ${event.userCode}`);
+        if (event.expiresInSeconds !== undefined) this.push(`expires in ${event.expiresInSeconds}s`);
+        break;
+      case "progress":
+        this.push(event.message);
+        break;
+    }
+    this.separator = true;
+  }
+
   private startTurn(): void {
     this.active = true;
     this.abort = new AbortController();
@@ -440,13 +606,9 @@ class Tui {
   private commitMessage(message: AssistantMessage): void {
     this.activity.reset();
     this.commitLines(this.reply.flush());
-    const text = message.content
-      .filter((block) => block.type === "text")
-      .map((block) => block.text)
-      .join("");
+    const text = assistantText(message);
     if (text.trim() !== "" && !this.streamed.includes(text)) {
-      const stream = new MarkdownStream();
-      this.commitLines([...stream.feed(text.trimEnd()), ...stream.flush()]);
+      this.commitLines([...this.reply.feed(text.trimEnd()), ...this.reply.flush()]);
     }
     this.streamed = "";
   }
@@ -575,6 +737,7 @@ class Tui {
     if (this.closed) return;
     this.closed = true;
     this.abort?.abort();
+    this.commandAbort?.abort();
     if (this.spinner) clearInterval(this.spinner);
     this.spinner = undefined;
     // Draws are deferred, so anything pushed since the last frame is still here.