mini-coder 0.5.0 → 0.5.1

package/README.md

@@ -83,6 +83,8 @@ Plugins can add more tools, but the core stays intentionally small.
 | `Tab`         | File path autocomplete (or command filter on `/`) |
 | `Ctrl+R`      | Search global raw input history                   |
 | `Ctrl+C`      | Graceful exit                                     |
+| `Ctrl+D`      | Graceful exit (EOF, when input is empty)          |
+| `:q`          | Graceful exit                                     |
 
 ## Headless one-shot mode
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-coder",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "A small, fast CLI coding agent",
   "module": "src/index.ts",
   "type": "module",

package/src/agent.ts

@@ -376,6 +376,44 @@ function handleAssistantStreamEvent(
   }
 }
 
+function buildIncompleteAssistantMessage(
+  opts: Pick<RunAgentOpts, "model" | "signal">,
+  partialAssistantMessage?: AssistantMessage,
+): AssistantMessage {
+  const stopReason = opts.signal?.aborted ? "aborted" : "error";
+  const errorMessage =
+    stopReason === "aborted"
+      ? "Request was aborted"
+      : "Stream ended without a final assistant message";
+
+  return {
+    role: "assistant",
+    content: partialAssistantMessage
+      ? cloneAssistantContent(partialAssistantMessage.content)
+      : [],
+    api: partialAssistantMessage?.api ?? opts.model.api,
+    provider: partialAssistantMessage?.provider ?? opts.model.provider,
+    model: partialAssistantMessage?.model ?? opts.model.id,
+    usage: partialAssistantMessage?.usage ?? {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        total: 0,
+      },
+    },
+    stopReason,
+    errorMessage,
+    timestamp: Date.now(),
+  };
+}
+
 async function streamAssistantMessage(
   opts: Pick<
     RunAgentOpts,
@@ -394,6 +432,12 @@ async function streamAssistantMessage(
     buildAgentContext(opts.systemPrompt, opts.messages, opts.tools),
     buildStreamOptions(opts.apiKey, opts.effort, opts.signal),
   );
+  const streamResult = eventStream.result();
+  let settledStreamResult: AssistantMessage | undefined;
+  void streamResult.then((message) => {
+    settledStreamResult = message;
+  });
+
   let assistantMessage: AssistantMessage | undefined;
   let partialAssistantMessage: AssistantMessage | undefined;
 
@@ -406,8 +450,12 @@ async function streamAssistantMessage(
       handleAssistantStreamEvent(event, opts.onEvent) ?? assistantMessage;
   }
 
+  // `end(result)` resolves the final result without emitting a terminal event.
+  await Promise.resolve();
   const finalAssistantMessage =
-    assistantMessage ?? (await eventStream.result());
+    assistantMessage ??
+    settledStreamResult ??
+    buildIncompleteAssistantMessage(opts, partialAssistantMessage);
   if (!partialAssistantMessage) {
     return finalAssistantMessage;
   }

package/src/git.ts

@@ -23,6 +23,8 @@ export interface GitState {
   root: string;
   /** Current branch name (empty string for detached HEAD). */
   branch: string;
+  /** Upstream tracking ref such as `origin/main`, or `null` when none exists. */
+  upstream: string | null;
   /** Number of staged (index) changes. */
   staged: number;
   /** Number of unstaged working-tree modifications. */
@@ -135,8 +137,12 @@ export async function getGitState(cwd: string): Promise<GitState | null> {
   if (root === null) return null;
 
   // Run remaining commands in parallel
-  const [branch, status, revList] = await Promise.all([
+  const [branch, upstream, status, revList] = await Promise.all([
     run(["branch", "--show-current"], cwd),
+    run(
+      ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+      cwd,
+    ),
     run(["status", "--porcelain"], cwd, false),
     run(["rev-list", "--left-right", "--count", "HEAD...@{upstream}"], cwd),
   ]);
@@ -155,6 +161,7 @@ export async function getGitState(cwd: string): Promise<GitState | null> {
   return {
     root,
     branch: branch ?? "",
+    upstream,
     staged,
     modified,
     untracked,

package/src/index.ts

@@ -10,7 +10,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import type {
   KnownProvider,
@@ -98,24 +98,45 @@ export const MAX_SESSIONS_PER_CWD = 20;
 /** Maximum raw prompt-history entries to retain globally. */
 export const MAX_PROMPT_HISTORY = 1_000;
 
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // ---------------------------------------------------------------------------
 // OAuth credential persistence
 // ---------------------------------------------------------------------------
 
 /** Load saved OAuth credentials from disk. */
-function loadOAuthCredentials(): Record<string, OAuthCredentials> {
-  if (!existsSync(AUTH_PATH)) return {};
+function loadOAuthCredentials(
+  path = AUTH_PATH,
+): Record<string, OAuthCredentials> {
+  if (!existsSync(path)) return {};
+
+  let parsed: unknown;
   try {
-    return JSON.parse(readFileSync(AUTH_PATH, "utf-8"));
-  } catch {
-    return {};
+    parsed = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+  } catch (error) {
+    throw new Error(
+      `Failed to read OAuth credentials ${path}: ${getErrorMessage(error)}`,
+    );
   }
+
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(
+      `Failed to read OAuth credentials ${path}: expected a JSON object`,
+    );
+  }
+
+  return parsed as Record<string, OAuthCredentials>;
 }
 
 /** Save OAuth credentials to disk. */
-function saveOAuthCredentials(creds: Record<string, OAuthCredentials>): void {
-  mkdirSync(DATA_DIR, { recursive: true });
-  writeFileSync(AUTH_PATH, JSON.stringify(creds, null, 2), "utf-8");
+function saveOAuthCredentials(
+  creds: Record<string, OAuthCredentials>,
+  path = AUTH_PATH,
+): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(creds, null, 2), "utf-8");
 }
 
 /** Return whether refreshed OAuth credentials differ from the persisted value. */

package/src/prompt.ts

@@ -99,10 +99,15 @@ function readAgentsMdFile(dir: string): AgentsMdFile | null {
   if (!existsSync(filePath)) {
     return null;
   }
-  return {
-    path: filePath,
-    content: readFileSync(filePath, "utf-8"),
-  };
+
+  try {
+    return {
+      path: filePath,
+      content: readFileSync(filePath, "utf-8"),
+    };
+  } catch {
+    return null;
+  }
 }
 
 /**
@@ -152,6 +157,7 @@ export function discoverAgentsMd(
  *
  * Fields are omitted when their values are zero. The git line format:
  * `Git: branch main | 3 staged, 1 modified, 2 untracked | +5 −2 vs origin/main`
+ * where the trailing upstream label reflects the repository's actual tracking ref.
  *
  * @param state - The git state to format.
  * @returns Formatted git status line.
@@ -171,7 +177,8 @@ export function formatGitLine(state: GitState): string {
     const ab: string[] = [];
     if (state.ahead > 0) ab.push(`+${state.ahead}`);
     if (state.behind > 0) ab.push(`\u2212${state.behind}`);
-    parts.push(`${ab.join(" ")} vs origin/${state.branch}`);
+    const upstream = state.upstream ? ` vs ${state.upstream}` : "";
+    parts.push(`${ab.join(" ")}${upstream}`);
   }
 
   return parts.join(" | ");

package/src/session.ts

@@ -10,7 +10,12 @@
  */
 
 import { Database } from "bun:sqlite";
-import type { AssistantMessage, Message } from "@mariozechner/pi-ai";
+import type {
+  AssistantMessage,
+  Message,
+  ToolResultMessage,
+  UserMessage,
+} from "@mariozechner/pi-ai";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -140,6 +145,21 @@ type MaxTurnRow = { max_turn: number | null };
 /** Row shape for `SELECT data` queries. */
 type DataRow = { data: string };
 
+const EMPTY_ASSISTANT_USAGE: AssistantMessage["usage"] = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    total: 0,
+  },
+};
+
 /** Row shape returned by `SELECT * FROM prompt_history`. */
 type PromptHistoryRow = {
   id: number;
@@ -319,14 +339,189 @@ function getMultipartUserPreview(
   return collapsePreviewText(text);
 }
 
+function isTextContentBlock(
+  value: unknown,
+): value is { type: "text"; text: string } {
+  const record = toRecord(value);
+  return record?.type === "text" && typeof record.text === "string";
+}
+
+function isImageContentBlock(
+  value: unknown,
+): value is { type: "image"; data: string; mimeType: string } {
+  const record = toRecord(value);
+  return (
+    record?.type === "image" &&
+    typeof record.data === "string" &&
+    typeof record.mimeType === "string"
+  );
+}
+
+function isThinkingContentBlock(
+  value: unknown,
+): value is Extract<AssistantMessage["content"][number], { type: "thinking" }> {
+  const record = toRecord(value);
+  return record?.type === "thinking" && typeof record.thinking === "string";
+}
+
+function isToolCallContentBlock(
+  value: unknown,
+): value is Extract<AssistantMessage["content"][number], { type: "toolCall" }> {
+  const record = toRecord(value);
+  return (
+    record?.type === "toolCall" &&
+    typeof record.id === "string" &&
+    typeof record.name === "string" &&
+    toRecord(record.arguments) !== null
+  );
+}
+
+function isAssistantUsage(value: unknown): value is AssistantMessage["usage"] {
+  const usageRecord = toRecord(value);
+  const costRecord = toRecord(usageRecord?.cost);
+  return (
+    usageRecord !== null &&
+    costRecord !== null &&
+    readFiniteNumber(usageRecord, "input") !== null &&
+    readFiniteNumber(usageRecord, "output") !== null &&
+    readFiniteNumber(usageRecord, "cacheRead") !== null &&
+    readFiniteNumber(usageRecord, "cacheWrite") !== null &&
+    readFiniteNumber(usageRecord, "totalTokens") !== null &&
+    readFiniteNumber(costRecord, "input") !== null &&
+    readFiniteNumber(costRecord, "output") !== null &&
+    readFiniteNumber(costRecord, "cacheRead") !== null &&
+    readFiniteNumber(costRecord, "cacheWrite") !== null &&
+    readFiniteNumber(costRecord, "total") !== null
+  );
+}
+
+function isStopReason(value: unknown): value is AssistantMessage["stopReason"] {
+  return (
+    value === "stop" ||
+    value === "length" ||
+    value === "toolUse" ||
+    value === "error" ||
+    value === "aborted"
+  );
+}
+
+function isUserMessageRecord(value: unknown): value is UserMessage {
+  const record = toRecord(value);
+  if (!record || record.role !== "user") {
+    return false;
+  }
+
+  return (
+    readFiniteNumber(record, "timestamp") !== null &&
+    (typeof record.content === "string" ||
+      (Array.isArray(record.content) &&
+        record.content.every(
+          (block) => isTextContentBlock(block) || isImageContentBlock(block),
+        )))
+  );
+}
+
+function parseAssistantMessageRecord(value: unknown): AssistantMessage | null {
+  const record = toRecord(value);
+  if (!record || record.role !== "assistant") {
+    return null;
+  }
+
+  const timestamp = readFiniteNumber(record, "timestamp");
+  if (
+    !Array.isArray(record.content) ||
+    !record.content.every(
+      (block) =>
+        isTextContentBlock(block) ||
+        isThinkingContentBlock(block) ||
+        isToolCallContentBlock(block),
+    ) ||
+    typeof record.api !== "string" ||
+    typeof record.provider !== "string" ||
+    typeof record.model !== "string" ||
+    !isStopReason(record.stopReason) ||
+    (record.errorMessage !== undefined &&
+      typeof record.errorMessage !== "string") ||
+    timestamp === null
+  ) {
+    return null;
+  }
+
+  return {
+    role: "assistant",
+    content: record.content,
+    api: record.api,
+    provider: record.provider,
+    model: record.model,
+    usage: isAssistantUsage(record.usage)
+      ? record.usage
+      : structuredClone(EMPTY_ASSISTANT_USAGE),
+    stopReason: record.stopReason,
+    ...(typeof record.errorMessage === "string"
+      ? { errorMessage: record.errorMessage }
+      : {}),
+    timestamp,
+  };
+}
+
+function isToolResultMessageRecord(value: unknown): value is ToolResultMessage {
+  const record = toRecord(value);
+  if (!record || record.role !== "toolResult") {
+    return false;
+  }
+
+  return (
+    typeof record.toolCallId === "string" &&
+    typeof record.toolName === "string" &&
+    typeof record.isError === "boolean" &&
+    Array.isArray(record.content) &&
+    record.content.every(
+      (block) => isTextContentBlock(block) || isImageContentBlock(block),
+    ) &&
+    readFiniteNumber(record, "timestamp") !== null
+  );
+}
+
+function isUiMessageRecord(value: unknown): value is UiMessage {
+  const record = toRecord(value);
+  if (!record || record.role !== "ui") {
+    return false;
+  }
+
+  return (
+    record.kind === "info" &&
+    typeof record.content === "string" &&
+    readFiniteNumber(record, "timestamp") !== null
+  );
+}
+
+function parsePersistedMessage(data: string): PersistedMessage | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(data) as unknown;
+  } catch {
+    return null;
+  }
+
+  if (
+    isUserMessageRecord(parsed) ||
+    isToolResultMessageRecord(parsed) ||
+    isUiMessageRecord(parsed)
+  ) {
+    return parsed;
+  }
+
+  return parseAssistantMessageRecord(parsed);
+}
+
 /** Read the first-user preview cached by the session-list query. */
 function readFirstUserPreview(messageData: string | null): string | null {
   if (!messageData) {
     return null;
   }
 
-  const message = JSON.parse(messageData) as PersistedMessage;
-  if (message.role !== "user") {
+  const message = parsePersistedMessage(messageData);
+  if (!message || message.role !== "user") {
     return null;
   }
 
@@ -434,7 +629,7 @@ export function filterModelMessages(
 }
 
 function toRecord(value: unknown): Record<string, unknown> | null {
-  return typeof value === "object" && value !== null
+  return typeof value === "object" && value !== null && !Array.isArray(value)
     ? (value as Record<string, unknown>)
     : null;
 }
@@ -620,7 +815,8 @@ export function appendMessage(
  * Load all messages for a session in insertion order.
  *
  * Messages are deserialized from their JSON representation back into
- * persisted app messages. The ordering matches the original append order
+ * persisted app messages. Invalid rows are skipped so corrupted session data
+ * does not crash the app. The ordering matches the original append order
  * (by autoincrement `id`), preserving the conversation flow.
  *
  * @param db - Open database handle.
@@ -633,7 +829,16 @@ export function loadMessages(
   sessionId: string,
 ): PersistedMessage[] {
   const rows = db.query<DataRow, [string]>(SQL.loadMessages).all(sessionId);
-  return rows.map((row) => JSON.parse(row.data) as PersistedMessage);
+  const messages: PersistedMessage[] = [];
+
+  for (const row of rows) {
+    const message = parsePersistedMessage(row.data);
+    if (message) {
+      messages.push(message);
+    }
+  }
+
+  return messages;
 }
 
 // ---------------------------------------------------------------------------

package/src/settings.ts

@@ -51,10 +51,15 @@ const THINKING_LEVELS = new Set<ThinkingLevel>([
   "xhigh",
 ]);
 
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 /**
  * Load and validate user settings from disk.
  *
- * Invalid or missing files are treated as empty settings.
+ * Missing files are treated as empty settings. Invalid JSON or unreadable files
+ * fail with a descriptive error instead of silently discarding saved state.
  *
  * @param path - Absolute path to `settings.json`.
  * @returns The validated settings object.
@@ -67,8 +72,10 @@ export function loadSettings(path: string): UserSettings {
   try {
     const raw = JSON.parse(readFileSync(path, "utf-8")) as unknown;
     return sanitizeSettings(raw);
-  } catch {
-    return {};
+  } catch (error) {
+    throw new Error(
+      `Failed to read settings ${path}: ${getErrorMessage(error)}`,
+    );
   }
 }
 

package/src/skills.ts

@@ -183,13 +183,17 @@ function readSkill(basePath: string, entry: string): Skill | null {
     return null;
   }
 
-  const content = readFileSync(skillPath, "utf-8");
-  const frontmatter = parseFrontmatter(content);
-  return {
-    name: frontmatter.name ?? entry,
-    description: frontmatter.description ?? "",
-    path: skillPath,
-  };
+  try {
+    const content = readFileSync(skillPath, "utf-8");
+    const frontmatter = parseFrontmatter(content);
+    return {
+      name: frontmatter.name ?? entry,
+      description: frontmatter.description ?? "",
+      path: skillPath,
+    };
+  } catch {
+    return null;
+  }
 }
 
 /**

package/src/ui/help.test.ts

@@ -23,4 +23,22 @@ describe("ui/help", () => {
       "/verbose  Toggle verbose tool rendering (currently off)",
     );
   });
+
+  test("buildHelpText includes the current Escape input-focus note", () => {
+    const helpState: HelpRenderState = {
+      providers: new Map(),
+      model: null,
+      agentsMd: [],
+      skills: [],
+      plugins: [],
+      showReasoning: DEFAULT_SHOW_REASONING,
+      verbose: false,
+    };
+
+    const text = buildHelpText(helpState);
+
+    expect(text).toContain("Escape blurs the input first");
+    expect(text).toContain("Tab re-focuses the input");
+    expect(text).toContain("Escape again interrupts the current turn");
+  });
 });

package/src/ui/help.ts

@@ -77,6 +77,12 @@ export function buildHelpText(state: HelpRenderState): string {
   }
 
   const providerNames = Array.from(state.providers.keys());
+  lines.push("");
+  lines.push("Note:");
+  lines.push("  While a turn is running, Escape blurs the input first.");
+  lines.push("  Tab re-focuses the input.");
+  lines.push("  Escape again interrupts the current turn.");
+
   lines.push("");
   lines.push(
     providerNames.length > 0

package/src/ui/status.test.ts

@@ -137,6 +137,7 @@ describe("ui/status", () => {
     state.git = {
       root: state.cwd,
       branch: "main",
+      upstream: "origin/main",
       staged: 1,
       modified: 2,
       untracked: 3,

package/src/ui.ts

@@ -8,7 +8,7 @@
  * @module
  */
 
-import { exec } from "node:child_process";
+import { spawn } from "node:child_process";
 import { platform } from "node:os";
 import {
   cel,
@@ -57,6 +57,20 @@ const PULSE_WIDTH = 5;
 /** Maximum number of committed messages rendered before older history is chunked. */
 const CONVERSATION_CHUNK_MESSAGES = 50;
 
+/** Centralized interactive quit rules for keypresses and submitted input. */
+const QUIT_RULES: Readonly<{
+  /** Submitted raw inputs that trigger graceful quit. */
+  inputs: ReadonlySet<string>;
+  /** Keypresses that always trigger graceful quit. */
+  keysAlways: ReadonlySet<string>;
+  /** Keypresses that trigger graceful quit only when input is empty. */
+  keysWhenEmptyInput: ReadonlySet<string>;
+}> = {
+  inputs: new Set([":q"]),
+  keysAlways: new Set(["ctrl+c"]),
+  keysWhenEmptyInput: new Set(["ctrl+d"]),
+};
+
 // ---------------------------------------------------------------------------
 // UI state (module-scoped, not in AppState)
 // ---------------------------------------------------------------------------
@@ -92,6 +106,23 @@ let stdinWasRaw = false;
 /** Active overlay for interactive commands (/model, /effort, etc.). */
 let activeOverlay: ActiveOverlay | null = null;
 
+/** Determine whether a raw input line should trigger a graceful quit. */
+export function isQuitInput(raw: string): boolean {
+  const trimmed = raw.trim();
+  return QUIT_RULES.inputs.has(trimmed);
+}
+
+/** Determine whether a keypress should trigger a graceful quit. */
+export function isQuitKey(key: string, input: string): boolean {
+  if (QUIT_RULES.keysAlways.has(key)) {
+    return true;
+  }
+  if (input === "" && QUIT_RULES.keysWhenEmptyInput.has(key)) {
+    return true;
+  }
+  return false;
+}
+
 /**
  * Reset all module-scoped UI state.
  *
@@ -299,6 +330,14 @@ export function createInputController(state: AppState): InputController {
     onKeyPress: (key) => {
       if (key === "enter") {
         const raw = inputValue;
+
+        if (isQuitInput(raw)) {
+          inputValue = "";
+          cel.render();
+          requestGracefulExit(state);
+          return false;
+        }
+
         inputValue = "";
         cel.render();
         handleInput(raw, state);
@@ -338,10 +377,49 @@ export function renderInputArea(
 // Runtime helpers and controllers
 // ---------------------------------------------------------------------------
 
-/** Open a URL in the user's default browser. */
-function openInBrowser(url: string): void {
-  const cmd = platform() === "darwin" ? "open" : "xdg-open";
-  exec(`${cmd} ${JSON.stringify(url)}`);
+/** Browser process handle used by the platform opener helper. */
+interface BrowserOpenProcess {
+  /** Detach the browser opener so the app does not wait on it. */
+  unref: () => void;
+  /** Optional error listener used by real child-process implementations. */
+  on?: (event: "error", listener: (error: Error) => void) => void;
+}
+
+/** Optional runtime overrides for browser launching. */
+interface OpenInBrowserRuntime {
+  /** Platform used to choose the opener binary. */
+  platform?: NodeJS.Platform;
+  /** Process launcher used for tests. */
+  spawn?: (
+    command: string,
+    args: string[],
+    options: { detached: boolean; stdio: "ignore" },
+  ) => BrowserOpenProcess;
+}
+
+/** Open a URL in the user's default browser without invoking a shell. */
+export function openInBrowser(
+  url: string,
+  runtime?: OpenInBrowserRuntime,
+): void {
+  const command =
+    (runtime?.platform ?? platform()) === "darwin" ? "open" : "xdg-open";
+  const launch =
+    runtime?.spawn ??
+    ((
+      cmd: string,
+      args: string[],
+      options: { detached: boolean; stdio: "ignore" },
+    ) => {
+      return spawn(cmd, args, options);
+    });
+  const child = launch(command, [url], {
+    detached: true,
+    stdio: "ignore",
+  });
+
+  child.on?.("error", () => {});
+  child.unref();
 }
 
 function scrollConversationToBottom(): void {
@@ -418,6 +496,11 @@ async function gracefulExit(state: AppState): Promise<void> {
   process.exit(0);
 }
 
+/** Request a graceful exit and hard-fail if shutdown errors. */
+function requestGracefulExit(state: AppState): void {
+  gracefulExit(state).catch(() => process.exit(1));
+}
+
 /** Restore the terminal to the shell before suspending. */
 function suspendTerminalUi(): void {
   stopDividerAnimation();
@@ -539,12 +622,8 @@ export function renderBaseLayout(
           commandController.showInputHistoryOverlay(state);
           return;
         }
-        if (key === "ctrl+c") {
-          gracefulExit(state).catch(() => process.exit(1));
-          return;
-        }
-        if (key === "ctrl+d" && inputValue === "") {
-          gracefulExit(state).catch(() => process.exit(1));
+        if (isQuitKey(key, inputValue)) {
+          requestGracefulExit(state);
           return;
         }
         if (key === "ctrl+z") {