mini-coder 0.7.1 → 0.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-coder",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "type": "module",
   "packageManager": "bun@1.3.13",
   "bin": {

package/src/agent.ts

@@ -78,10 +78,6 @@ export async function* streamAgent(
 
   // Main agent loop, continues until llm sends a response other than toolCall or has no tool calls.
   while (true) {
-    let estimate = estimateTokens(JSON.stringify(llmCtx));
-    // 80k is the agreed uppon threshold to the DUMB ZONE
-    if (estimate > 80000) compactContext(llmCtx.messages);
-
     const s = streamSimple(agentCtx.options.model, llmCtx, {
       reasoning: agentCtx.options.effort,
       signal: agentCtx.signal,
@@ -115,9 +111,6 @@ export async function* streamAgent(
             yield { type: "message_update", partial };
           }
 
-          estimate = estimateTokens(JSON.stringify(llmCtx));
-          // 80k is the agreed uppon threshold to the DUMB ZONE
-          if (estimate > 80000) compactContext(llmCtx.messages);
           break;
         }
 
@@ -134,6 +127,12 @@ export async function* streamAgent(
           return;
         }
       }
+
+      // Experiment: use this inside the inner loop for "running" compaction
+      // after we are in the dumb zone.
+      const estimate = estimateTokens(JSON.stringify(llmCtx));
+      // 80k is the agreed uppon threshold to the DUMB ZONE
+      if (estimate > 80000) compactContext(llmCtx.messages);
     }
 
     const message = await s.result();

package/src/args.ts

@@ -9,6 +9,7 @@ import {
 import { Value } from "typebox/value";
 import { getAvailableProviders, isOAuthProvider, loginOAuth } from "./oauth";
 import { DATA_DIR, SETTINGS_PATH } from "./shared.ts";
+import { DEFAULT_TUI_THEME_ID } from "./themes.ts";
 import {
   type CliOptions,
   CliOptionsSchema,
@@ -63,7 +64,14 @@ async function getSettings(): Promise<Settings | undefined> {
   }
 
   const jsonText = await file.text();
-  const settings = JSON.parse(jsonText) as unknown;
+  let settings: unknown;
+
+  try {
+    settings = JSON.parse(jsonText) as unknown;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid settings JSON: ${message}`);
+  }
 
   return parseSettings(settings, "settings");
 }
@@ -149,6 +157,7 @@ export async function handleArgv(argv: string[]): Promise<CliOptions> {
       ? DEFAULT_MODEL_ID
       : getFirstModelConfig(settingsProvider, customProviders).id);
   const settingsEffort = settings?.effort ?? DEFAULT_EFFORT;
+  const settingsTheme = settings?.theme ?? DEFAULT_TUI_THEME_ID;
   let provider: string = settingsProvider;
   let modelId = settingsModelId;
   let effort: string = settingsEffort;
@@ -273,6 +282,7 @@ export async function handleArgv(argv: string[]): Promise<CliOptions> {
     effort: cliSettings.effort,
     prompt,
     customProviders,
+    theme: settingsTheme,
   });
   const nextSettings = parseSettings(
     {
@@ -280,6 +290,7 @@ export async function handleArgv(argv: string[]): Promise<CliOptions> {
       model: options.model.id,
       effort: options.effort,
       customProviders,
+      theme: options.theme,
     },
     "settings",
   );

package/src/error-handling.test.ts

@@ -0,0 +1,163 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runBashTool } from "./tool-bash.ts";
+import { runEditTool } from "./tool-edit.ts";
+import { runReadTool } from "./tool-read.ts";
+import type { ToolRunnerEvent } from "./types.ts";
+
+const originalDataDir = Bun.env.MINI_CODER_DATA_DIR;
+const testHome = await mkdtemp(join(tmpdir(), "mini-coder-errors-"));
+const dataDir = join(testHome, "data");
+Bun.env.MINI_CODER_DATA_DIR = dataDir;
+
+const sessionsDir = join(dataDir, "sessions");
+const { handleArgv } = await import("./args.ts");
+const { getAvailableProviders } = await import("./oauth.ts");
+const { getSession, listSessionsForCwd } = await import("./session.ts");
+
+type ResultEvent = Extract<ToolRunnerEvent, { type: "result" }>;
+
+async function collectToolEvents(
+  events: AsyncGenerator<ToolRunnerEvent>,
+): Promise<ToolRunnerEvent[]> {
+  const collected: ToolRunnerEvent[] = [];
+
+  for await (const event of events) {
+    collected.push(event);
+  }
+
+  return collected;
+}
+
+function resultEvent(events: ToolRunnerEvent[]): ResultEvent {
+  const result = events.findLast(
+    (event): event is ResultEvent => event.type === "result",
+  );
+
+  if (!result) {
+    throw new Error("Tool did not yield a result");
+  }
+
+  return result;
+}
+
+async function toolResult(
+  events: AsyncGenerator<ToolRunnerEvent>,
+): Promise<ResultEvent> {
+  return resultEvent(await collectToolEvents(events));
+}
+
+beforeEach(async () => {
+  await rm(dataDir, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  if (originalDataDir === undefined) {
+    delete Bun.env.MINI_CODER_DATA_DIR;
+  } else {
+    Bun.env.MINI_CODER_DATA_DIR = originalDataDir;
+  }
+
+  await rm(testHome, { recursive: true, force: true });
+});
+
+describe("tool runner error handling", () => {
+  test("read and edit report missing files as tool results", async () => {
+    const missingPath = join(testHome, "missing.txt");
+
+    const readResult = await toolResult(runReadTool({ path: missingPath }));
+    expect(readResult.text).toBe(`File not found: ${missingPath}`);
+
+    const editResult = await toolResult(
+      runEditTool({ path: missingPath, oldText: "old", newText: "new" }),
+    );
+    expect(editResult.text).toBe(`File not found: ${missingPath}`);
+  });
+
+  test("edit refuses unsafe writes and preserves the file", async () => {
+    const path = join(testHome, "edit.txt");
+    await writeFile(path, "one\none\n");
+
+    const ambiguous = await toolResult(
+      runEditTool({ path, oldText: "one", newText: "two" }),
+    );
+    expect(ambiguous.text).toContain("Multiple matches found");
+    expect(await Bun.file(path).text()).toBe("one\none\n");
+
+    const missing = await toolResult(
+      runEditTool({ path, oldText: "missing", newText: "two" }),
+    );
+    expect(missing.text).toBe(`Old text not found in: ${path}`);
+    expect(await Bun.file(path).text()).toBe("one\none\n");
+
+    const abortController = new AbortController();
+    abortController.abort();
+    await writeFile(path, "hello");
+
+    const aborted = await toolResult(
+      runEditTool(
+        { path, oldText: "hello", newText: "bye" },
+        abortController.signal,
+      ),
+    );
+    expect(aborted.text).toBe("Aborted before write.");
+    expect(await Bun.file(path).text()).toBe("hello");
+  });
+
+  test("bash reports non-zero exits instead of throwing", async () => {
+    const result = await toolResult(
+      runBashTool({ command: 'printf "bad"; exit 7' }),
+    );
+
+    expect(result.text).toBe("bad\n\nExit code: 7");
+  });
+});
+
+describe("startup file error handling", () => {
+  test("settings JSON parse failures are labelled", async () => {
+    await mkdir(dataDir, { recursive: true });
+    await writeFile(join(dataDir, "settings.json"), "{");
+
+    await expect(handleArgv([])).rejects.toThrow("Invalid settings JSON:");
+  });
+
+  test("auth JSON parse failures are labelled", async () => {
+    await mkdir(dataDir, { recursive: true });
+    await writeFile(join(dataDir, "auth.json"), "{");
+
+    await expect(getAvailableProviders()).rejects.toThrow("Invalid auth JSON:");
+  });
+});
+
+describe("session file error handling", () => {
+  test("listSessionsForCwd ignores missing dirs and bad session files", async () => {
+    expect(await listSessionsForCwd()).toEqual([]);
+
+    await mkdir(sessionsDir, { recursive: true });
+    await writeFile(join(sessionsDir, "broken.json"), "{");
+    await writeFile(
+      join(sessionsDir, "elsewhere.json"),
+      JSON.stringify({ id: "elsewhere", cwd: "/elsewhere", messages: [] }),
+    );
+    await writeFile(
+      join(sessionsDir, "ok.json"),
+      JSON.stringify({
+        id: "ok",
+        cwd: process.cwd(),
+        messages: [{ role: "user", content: "hi", timestamp: 2 }],
+      }),
+    );
+
+    const sessions = await listSessionsForCwd();
+    expect(sessions.map((session) => session.id)).toEqual(["ok"]);
+  });
+
+  test("getSession returns undefined for bad session files", async () => {
+    await mkdir(sessionsDir, { recursive: true });
+    await writeFile(join(sessionsDir, "broken.json"), "{");
+
+    expect(await getSession("broken")).toBeUndefined();
+  });
+});

package/src/headless.ts

@@ -39,6 +39,7 @@ export async function streamHeadless(
   };
 
   const agent = streamAgent(ctx);
+
   for await (const ev of agent) {
     switch (ev.type) {
       case "message_end":

package/src/index.ts

@@ -4,10 +4,18 @@ import { getBranchLabel } from "./git.ts";
 import { streamHeadless } from "./headless.ts";
 import { initTUI } from "./tui.ts";
 import type { TUIState } from "./types.ts";
+import { updateMiniCoder } from "./update.ts";
 
 export async function main(): Promise<void> {
+  const argv = process.argv.slice(2);
+
+  if (argv.includes("--update")) {
+    await updateMiniCoder();
+    return;
+  }
+
   const cwd = basename(process.cwd());
-  const options = await handleArgv(process.argv.slice(2));
+  const options = await handleArgv(argv);
 
   function leave(msg?: string) {
     if (msg) console.log(msg);

package/src/oauth.ts

@@ -1,3 +1,4 @@
+import { mkdir } from "node:fs/promises";
 import readline from "node:readline";
 
 import { getEnvApiKey, getProviders } from "@earendil-works/pi-ai";
@@ -10,7 +11,7 @@ import {
   type OAuthProviderId,
   type OAuthSelectPrompt,
 } from "@earendil-works/pi-ai/oauth";
-import { AUTH_PATH as AUTH_FILE } from "./shared";
+import { AUTH_PATH as AUTH_FILE, DATA_DIR } from "./shared";
 import type { CliOptions, SavedOAuthCreds } from "./types";
 
 type ReadlineInterface = ReturnType<typeof readline.createInterface>;
@@ -134,13 +135,19 @@ export async function getApiKey(options: CliOptions) {
 export async function readCreds(): Promise<SavedOAuthCreds> {
   const file = Bun.file(AUTH_FILE);
   if (await file.exists()) {
-    return JSON.parse(await file.text());
+    try {
+      return JSON.parse(await file.text());
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Invalid auth JSON: ${message}`);
+    }
   }
 
   return {};
 }
 
 async function writeCreds(creds: SavedOAuthCreds) {
+  await mkdir(DATA_DIR, { recursive: true });
   await Bun.write(AUTH_FILE, JSON.stringify(await mergeCreds(creds)));
 }
 

package/src/prompt.ts

@@ -11,12 +11,11 @@ export const MAIN_PROMPT = `You are a coding agent interacting with users via th
 - Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without unnecessary superlatives, praise, or emotional validation.
 - User messages and Tool results may include <system-reminder> tags. These contain system-generated reminders and bear no direct relation to the specific tool result in which they appear.
 - You have access to bash, read and edit tools. Prefer using read and edit for file operations, use bash for finding read candidates or to run development commands.
-- If a tool call fails or is denied, do NOT re-attempt the exact same call. Analyze why it failed and adjust your approach.
 - Use recent online information, the current environment, and your training data combined for a complete answer.
 - Ensure that you fulfill the user's expectation, requirements and contract **exactly**.
+- Do not overstate what changed or what was verified. Summaries must match the diff.
 - Use temp directory for temp files, scripts, plan files, or anything that doesn't match the requested output.
 - Be concise. Use a professional colleague tone: direct, never condescending, and never rude.
-- Do not overstate what changed or what was verified. Summaries must match the diff.
 `;
 
 async function getDir() {

package/src/session.ts

@@ -9,7 +9,6 @@ export async function ensureSessionsDir(): Promise<void> {
   await mkdir(SESSIONS_DIR, { recursive: true });
 }
 
-// readSession: writes the session
 export async function getSession(id: string): Promise<Session | undefined> {
   const file = Bun.file(join(SESSIONS_DIR, `${id}.json`));
 
@@ -17,11 +16,16 @@ export async function getSession(id: string): Promise<Session | undefined> {
     return;
   }
 
-  const sessionJson = await file.text();
-  const parsed = JSON.parse(sessionJson) as unknown;
-  const valid = Value.Check(SessionSchema, parsed);
+  try {
+    const sessionJson = await file.text();
+    const parsed = JSON.parse(sessionJson) as unknown;
+    const valid = Value.Check(SessionSchema, parsed);
+
+    if (valid) return parsed;
+  } catch {
+    return;
+  }
 
-  if (valid) return parsed;
   return;
 }
 
@@ -65,7 +69,6 @@ export async function saveSession(s: Session) {
   await Bun.write(file, JSON.stringify(s));
 }
 
-// updateSession: finds and appends to the existing setting file
 export async function updateSession(id: string, messages: Message[]) {
   const existing = await getSession(id);
   if (existing) {

package/src/shared.ts

@@ -4,7 +4,8 @@ import { parseDocument } from "yaml";
 
 // Mixed bag of helpers that can be shared across the codebase
 
-export const DATA_DIR = join(homedir(), ".config", "mini-coder");
+export const DATA_DIR =
+  Bun.env.MINI_CODER_DATA_DIR ?? join(homedir(), ".config", "mini-coder");
 export const SESSIONS_DIR = join(DATA_DIR, "sessions");
 export const AUTH_PATH = join(DATA_DIR, "auth.json");
 export const SETTINGS_PATH = join(DATA_DIR, "settings.json");

package/src/themes.ts

@@ -0,0 +1,234 @@
+import type { SyntaxHighlightTheme } from "@cel-tui/components";
+import type { Color, Theme } from "@cel-tui/core";
+
+export const TUI_THEME_IDS = [
+  "ansi16",
+  "molokai-dark",
+  "molokai-light",
+] as const;
+
+export type TUIThemeId = (typeof TUI_THEME_IDS)[number];
+
+export interface TUIThemeDefinition {
+  id: TUIThemeId;
+  label: string;
+  palette: Theme;
+  syntax: SyntaxHighlightTheme;
+  rootFgColor?: Color;
+  rootBgColor?: Color;
+  userMessageBgColor?: Color;
+}
+
+const ANSI_SLOT_HEX: Record<Color, string> = {
+  color00: "#000000",
+  color01: "#cd3131",
+  color02: "#0dbc79",
+  color03: "#e5e510",
+  color04: "#2472c8",
+  color05: "#bc3fbc",
+  color06: "#11a8cd",
+  color07: "#e5e5e5",
+  color08: "#666666",
+  color09: "#f14c4c",
+  color10: "#23d18b",
+  color11: "#f5f543",
+  color12: "#3b8eea",
+  color13: "#d670d6",
+  color14: "#29b8db",
+  color15: "#ffffff",
+};
+
+export const theme = {
+  black: "color00",
+  red: "color01",
+  green: "color02",
+  yellow: "color03",
+  blue: "color04",
+  magenta: "color05",
+  cyan: "color06",
+  white: "color07",
+  bblack: "color08",
+  bred: "color09",
+  bgreen: "color10",
+  byellow: "color11",
+  bblue: "color12",
+  bmagenta: "color13",
+  bcyan: "color14",
+  bwhite: "color15",
+} as const satisfies Record<string, Color>;
+
+const ansi16Palette: Theme = {
+  color00: 0,
+  color01: 1,
+  color02: 2,
+  color03: 3,
+  color04: 4,
+  color05: 5,
+  color06: 6,
+  color07: 7,
+  color08: 8,
+  color09: 9,
+  color10: 10,
+  color11: 11,
+  color12: 12,
+  color13: 13,
+  color14: 14,
+  color15: 15,
+};
+
+const molokaiDarkPalette: Theme = {
+  color00: "#272822",
+  color01: "#f92672",
+  color02: "#a6e22e",
+  color03: "#e6db74",
+  color04: "#66d9ef",
+  color05: "#f92672",
+  color06: "#66d9ef",
+  color07: "#f8f8f2",
+  color08: "#6f705f",
+  color09: "#ff6188",
+  color10: "#a6e22e",
+  color11: "#ffd866",
+  color12: "#78dce8",
+  color13: "#ae81ff",
+  color14: "#66d9ef",
+  color15: "#ffffff",
+};
+
+const molokaiLightPalette: Theme = {
+  color00: "#272822",
+  color01: "#ff5f87",
+  color02: "#8bcf26",
+  color03: "#c7a100",
+  color04: "#61aeee",
+  color05: "#d16dff",
+  color06: "#00a8b5",
+  color07: "#f2efe4",
+  color08: "#5f6060",
+  color09: "#b0003a",
+  color10: "#3f7d00",
+  color11: "#725f00",
+  color12: "#005f9f",
+  color13: "#7f2caf",
+  color14: "#007885",
+  color15: "#fffdf5",
+};
+
+const slotColor = (slot: Color) => ANSI_SLOT_HEX[slot];
+
+function syntaxScope(
+  scope: string | readonly string[],
+  foreground: Color,
+  fontStyle?: string,
+) {
+  return {
+    scope,
+    settings: {
+      foreground: slotColor(foreground),
+      ...(fontStyle ? { fontStyle } : {}),
+    },
+  };
+}
+
+const molokaiDarkSyntax = {
+  name: "mini-coder-molokai-dark",
+  type: "dark",
+  fg: slotColor("color07"),
+  tokenColors: [
+    syntaxScope(["comment", "markup.quote"], "color08", "italic"),
+    syntaxScope(["keyword", "operator"], "color05"),
+    syntaxScope(["string", "escape", "markup.list"], "color03"),
+    syntaxScope(["number", "regexp"], "color13"),
+    syntaxScope(["function", "command", "markup.code"], "color10"),
+    syntaxScope(["builtin", "property", "type", "meta"], "color06"),
+    syntaxScope("markup.heading", "color04", "bold"),
+    syntaxScope(["diff.deleted", "diff.file.old"], "color09"),
+    syntaxScope(["diff.inserted", "diff.file.new"], "color10"),
+    syntaxScope("diff.hunk", "color13"),
+    syntaxScope(["diff.header", "diff.no-newline"], "color08"),
+  ],
+} as const satisfies SyntaxHighlightTheme;
+
+const molokaiLightSyntax = {
+  name: "mini-coder-molokai-light",
+  type: "light",
+  fg: slotColor("color00"),
+  tokenColors: [
+    syntaxScope(["comment", "markup.quote"], "color08", "italic"),
+    syntaxScope(["keyword", "operator"], "color13"),
+    syntaxScope(["string", "escape", "markup.list"], "color11"),
+    syntaxScope(["number", "regexp"], "color09"),
+    syntaxScope(["function", "command", "markup.code"], "color10"),
+    syntaxScope(["builtin", "property", "type", "meta"], "color14"),
+    syntaxScope("markup.heading", "color12", "bold"),
+    syntaxScope(["diff.deleted", "diff.file.old"], "color09"),
+    syntaxScope(["diff.inserted", "diff.file.new"], "color10"),
+    syntaxScope("diff.hunk", "color13"),
+    syntaxScope(["diff.header", "diff.no-newline"], "color08"),
+  ],
+} as const satisfies SyntaxHighlightTheme;
+
+export const DEFAULT_TUI_THEME_ID: TUIThemeId = "ansi16";
+
+export const TUI_THEMES = {
+  ansi16: {
+    id: "ansi16",
+    label: "ansi16",
+    palette: ansi16Palette,
+    syntax: "default",
+    userMessageBgColor: theme.bblack,
+  },
+  "molokai-dark": {
+    id: "molokai-dark",
+    label: "molokai dark",
+    palette: molokaiDarkPalette,
+    syntax: molokaiDarkSyntax,
+    rootFgColor: theme.bwhite,
+    rootBgColor: theme.black,
+    userMessageBgColor: theme.bblack,
+  },
+  "molokai-light": {
+    id: "molokai-light",
+    label: "molokai light",
+    palette: molokaiLightPalette,
+    syntax: molokaiLightSyntax,
+    rootFgColor: theme.black,
+    rootBgColor: theme.bwhite,
+    userMessageBgColor: theme.white,
+  },
+} as const satisfies Record<TUIThemeId, TUIThemeDefinition>;
+
+export const activeTuiTheme: Theme = { ...ansi16Palette };
+
+export function applyTUITheme(id: TUIThemeId): void {
+  Object.assign(activeTuiTheme, TUI_THEMES[id].palette);
+}
+
+export function getTUITheme(id: TUIThemeId): TUIThemeDefinition {
+  return TUI_THEMES[id];
+}
+
+export function textColorForBackground(
+  bgColor: Color,
+  themeId: TUIThemeId,
+): Color {
+  if (bgColor === theme.bblack) return theme.bwhite;
+
+  if (
+    themeId === "molokai-light" &&
+    (
+      [
+        theme.bred,
+        theme.bgreen,
+        theme.byellow,
+        theme.bblue,
+        theme.bmagenta,
+        theme.bcyan,
+      ] as readonly Color[]
+    ).includes(bgColor)
+  ) {
+    return theme.bwhite;
+  }
+
+  return theme.black;
+}

package/src/tool-bash.ts

@@ -66,10 +66,7 @@ export async function* runBashTool(
 
   const exitCode = await proc.exited;
 
-  let result = `${output.length ? output : "(no ouput)"}\n\nExit code: ${exitCode}`;
-  if (output.length) {
-    result += `${output}`;
-  }
+  const result = `${output.length ? output : "(no output)"}\n\nExit code: ${exitCode}`;
 
   yield {
     type: "result",

package/src/tui-components.ts

@@ -1,32 +1,9 @@
 import { type Color, HStack, Text } from "@cel-tui/core";
 import { onceEvery } from "./shared";
+import { textColorForBackground, theme } from "./themes";
 import type { TUIState } from "./types";
 
-export const theme = {
-  black: "color00" as Color,
-  bblack: "color08" as Color,
-
-  red: "color01" as Color,
-  bred: "color09" as Color,
-
-  green: "color02" as Color,
-  bgreen: "color10" as Color,
-
-  yellow: "color03" as Color,
-  byellow: "color11" as Color,
-
-  blue: "color04" as Color,
-  bblue: "color12" as Color,
-
-  magenta: "color05" as Color,
-  bmagenta: "color13" as Color,
-
-  cyan: "color06" as Color,
-  bcyan: "color14" as Color,
-
-  white: "color07" as Color,
-  bwhite: "color15" as Color,
-};
+export { theme };
 
 export function TextPill(
   content: string,
@@ -100,7 +77,7 @@ export function ActivityPill(state: TUIState, spinnerFrame: string) {
 
 export function ContextPill(state: TUIState) {
   let text = "";
-  let bg = theme.bgreen;
+  let bg: Color = theme.bgreen;
   if (!state.contextSize) {
     text = "0%";
     bg = theme.bwhite;
@@ -126,7 +103,7 @@ export function ContextPill(state: TUIState) {
 
   text += ` (${state.options.model.contextWindow / 1000}k)`;
 
-  return TextPill(text, theme.black, bg);
+  return TextPill(text, textColorForBackground(bg, state.options.theme), bg);
 }
 
 export function GitPill(state: TUIState) {

package/src/tui-conversation.ts

@@ -1,44 +1,71 @@
-import { SyntaxHighlight } from "@cel-tui/components";
-import { HStack, type Node, Text, VStack } from "@cel-tui/core";
+import {
+  SyntaxHighlight,
+  type SyntaxHighlightTheme,
+} from "@cel-tui/components";
+import { type Color, HStack, type Node, Text, VStack } from "@cel-tui/core";
 import { estimateTokens } from "./shared";
+import { getTUITheme, textColorForBackground } from "./themes";
 import { TextPill, theme } from "./tui-components";
 import type { TUIMessage, TUIState, TUIToolCall } from "./types";
 
-export function emptyState(): Node {
+export function emptyState(state: TUIState): Node {
   const randColor = theme.bgreen;
+  const shortcutFgColor =
+    state.options.theme === "ansi16"
+      ? randColor
+      : textColorForBackground(theme.bblack, state.options.theme);
+  const updateNotice = state.availableUpdate
+    ? [
+        HStack({ gap: 1 }, [
+          TextPill("update", shortcutFgColor, theme.bblack, 13),
+          Text(
+            `mini-coder ${state.availableUpdate.latestVersion} is available. Run mc --update.`,
+            { fgColor: theme.bblack },
+          ),
+        ]),
+      ]
+    : [];
   return HStack({ flex: 1, alignItems: "center" }, [
     VStack({ flex: 1, alignItems: "center", gap: 1 }, [
       HStack({ gap: 1 }, [
         Text("mini"),
-        TextPill("coder", theme.black, randColor),
+        TextPill(
+          "coder",
+          textColorForBackground(randColor, state.options.theme),
+          randColor,
+        ),
       ]),
       VStack({ gap: 1 }, [
         HStack({ gap: 1 }, [
-          TextPill("/new", randColor, theme.bblack, 13),
+          TextPill("/new", shortcutFgColor, theme.bblack, 13),
           Text("Start a new session from the input box.", {
             fgColor: theme.bblack,
           }),
         ]),
         HStack({ gap: 1 }, [
-          TextPill("ctrl+p", randColor, theme.bblack, 13),
+          TextPill("ctrl+p", shortcutFgColor, theme.bblack, 13),
           Text("Menu for session history, and settings.", {
             fgColor: theme.bblack,
           }),
         ]),
         HStack({ gap: 1 }, [
-          TextPill("ESC", randColor, theme.bblack, 13),
+          TextPill("ESC", shortcutFgColor, theme.bblack, 13),
           Text("Abort agent response.", { fgColor: theme.bblack }),
         ]),
         HStack({ gap: 1 }, [
-          TextPill("ctrl+c|d|q", randColor, theme.bblack, 13),
+          TextPill("ctrl+c|d|q", shortcutFgColor, theme.bblack, 13),
           Text("Quit.", { fgColor: theme.bblack }),
         ]),
+        ...updateNotice,
       ]),
     ]),
   ]);
 }
 
-function ConversationMessageToolCall(call: TUIToolCall) {
+function ConversationMessageToolCall(
+  call: TUIToolCall,
+  syntaxTheme: SyntaxHighlightTheme,
+) {
   let outputNode: Node | null = null;
 
   // Compress read and bash calls
@@ -64,7 +91,7 @@ function ConversationMessageToolCall(call: TUIToolCall) {
 
     outputNode = VStack({ width: "100%" }, blocks);
   } else if (call.tool === "edit") {
-    outputNode = SyntaxHighlight(call.output, "patch");
+    outputNode = SyntaxHighlight(call.output, "patch", { theme: syntaxTheme });
   } else {
     outputNode = Text(call.output, { wrap: "word" });
   }
@@ -81,7 +108,7 @@ function ConversationMessageToolCall(call: TUIToolCall) {
 
       // Syntax highlight bash args
       if (call.tool === "bash") {
-        node = SyntaxHighlight(String(value), "bash");
+        node = SyntaxHighlight(String(value), "bash", { theme: syntaxTheme });
         return node;
       }
 
@@ -99,7 +126,11 @@ function ConversationMessageToolCall(call: TUIToolCall) {
   ]);
 }
 
-function ConversationMessage(message: TUIMessage) {
+function ConversationMessage(
+  message: TUIMessage,
+  syntaxTheme: SyntaxHighlightTheme,
+  userMessageBgColor: Color | undefined,
+) {
   const blocks: Node[] = [];
 
   if (message.thinking) {
@@ -118,17 +149,22 @@ function ConversationMessage(message: TUIMessage) {
       VStack(
         {
           width: "100%",
-          bgColor: message.role === "user" ? theme.bblack : undefined,
+          bgColor: message.role === "user" ? userMessageBgColor : undefined,
           padding: { y: 1, x: message.role === "user" ? 1 : 0 },
         },
-        [SyntaxHighlight(message.text, "markdown")],
+        [SyntaxHighlight(message.text, "markdown", { theme: syntaxTheme })],
       ),
     );
   }
 
   if (message.toolCalls?.length) {
     blocks.push(
-      VStack({ gap: 1 }, message.toolCalls.map(ConversationMessageToolCall)),
+      VStack(
+        { gap: 1 },
+        message.toolCalls.map((call) =>
+          ConversationMessageToolCall(call, syntaxTheme),
+        ),
+      ),
     );
   }
 
@@ -158,6 +194,8 @@ function ConversationMessage(message: TUIMessage) {
 }
 
 export function Conversation(state: TUIState) {
+  const activeTheme = getTUITheme(state.options.theme);
+
   return VStack(
     {
       flex: 1,
@@ -169,6 +207,12 @@ export function Conversation(state: TUIState) {
         state.stickToBottom = offset >= maxOffset;
       },
     },
-    state.tuiMessages.map(ConversationMessage),
+    state.tuiMessages.map((message) =>
+      ConversationMessage(
+        message,
+        activeTheme.syntax,
+        activeTheme.userMessageBgColor,
+      ),
+    ),
   );
 }

package/src/tui-overlay.ts

@@ -1,4 +1,4 @@
-import { HStack, Text, TextInput, VStack } from "@cel-tui/core";
+import { cel, HStack, Text, TextInput, VStack } from "@cel-tui/core";
 import {
   getModels,
   type Message,
@@ -9,6 +9,7 @@ import { saveSettings } from "./args";
 import { getAvailableProviders } from "./oauth";
 import { listSessionsForCwd } from "./session";
 import { estimateTokens, formatTimestamp } from "./shared";
+import { applyTUITheme, getTUITheme, TUI_THEME_IDS } from "./themes";
 import { TextPill, theme } from "./tui-components";
 import type { SelectOptions, SelectState, Session, TUIState } from "./types";
 
@@ -344,12 +345,28 @@ export function mainMenu(state: TUIState, initialPane = "main") {
     })),
   });
 
+  const themesPane = (): MenuPane => ({
+    label: "themes",
+    filter: "",
+    list: TUI_THEME_IDS.map((id) => {
+      const tuiTheme = getTUITheme(id);
+      return {
+        label:
+          id === state.options.theme
+            ? `${tuiTheme.label} (current)`
+            : tuiTheme.label,
+        value: id,
+      };
+    }),
+  });
+
   const mainPane: MenuPane = {
     label: "main",
     filter: state.prompt.length ? state.prompt : "",
     list: [
       { label: "models and providers", value: "providers" },
       { label: "reasoning effort", value: "effort" },
+      { label: "themes", value: "themes" },
       { label: "sessions", value: "sessions" },
       { label: "fork", value: "fork" },
     ],
@@ -359,7 +376,7 @@ export function mainMenu(state: TUIState, initialPane = "main") {
     filter: "",
     list: efforts,
   };
-  const panes: MenuPane[] = [effortPane];
+  const panes: MenuPane[] = [effortPane, themesPane()];
   let currentPane = initialPane === "fork" ? forkPane() : mainPane;
   let selectedProvider: string | undefined;
 
@@ -387,6 +404,14 @@ export function mainMenu(state: TUIState, initialPane = "main") {
     state.overlay = false;
   };
 
+  const requestThemeRefresh = () => {
+    state.forceThemeRefresh = true;
+    setTimeout(() => {
+      state.forceThemeRefresh = false;
+      cel.render();
+    }, 0);
+  };
+
   const toTUIMessage = (msg: Message) => {
     const textFromContent = (
       content: string | { type: string; text?: string }[],
@@ -509,6 +534,24 @@ export function mainMenu(state: TUIState, initialPane = "main") {
         return;
       }
 
+      if (currentPane.label === "themes") {
+        const nextTheme = TUI_THEME_IDS.find((id) => id === s.selected);
+        if (!nextTheme) return;
+
+        state.options.theme = nextTheme;
+        applyTUITheme(nextTheme);
+        saveSettings({
+          provider: state.options.provider,
+          model: state.options.model.id,
+          effort: state.options.effort,
+          customProviders: state.options.customProviders,
+          theme: nextTheme,
+        });
+        requestThemeRefresh();
+        closeMenu(s);
+        return;
+      }
+
       if (currentPane.label === "providers") {
         const provider = currentProviders.find((v) => v === s.selected);
         if (!provider) return;
@@ -541,6 +584,7 @@ export function mainMenu(state: TUIState, initialPane = "main") {
           model: model.id,
           effort: state.options.effort,
           customProviders: state.options.customProviders,
+          theme: state.options.theme,
         });
         closeMenu(s);
         return;
@@ -556,6 +600,7 @@ export function mainMenu(state: TUIState, initialPane = "main") {
           model: state.options.model.id,
           effort: effort,
           customProviders: state.options.customProviders,
+          theme: state.options.theme,
         });
         closeMenu(s);
       }

package/src/tui.ts

@@ -1,6 +1,3 @@
-import { stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { cel, HStack, ProcessTerminal, VStack } from "@cel-tui/core";
 import type {
   AssistantMessage,
@@ -16,6 +13,7 @@ import {
 } from "./prompt";
 import { updateSession } from "./session";
 import { estimateTokens, formatTimestamp, secureRandomString } from "./shared";
+import { activeTuiTheme, applyTUITheme, getTUITheme } from "./themes";
 import { bash, runBashTool } from "./tool-bash";
 import { edit, runEditTool } from "./tool-edit";
 import { read, runReadTool } from "./tool-read";
@@ -32,6 +30,11 @@ import { Conversation, emptyState } from "./tui-conversation";
 import { Editor } from "./tui-editor";
 import { mainMenu } from "./tui-overlay";
 import type { AgentContex, ToolAndRunner, TUIMessage, TUIState } from "./types";
+import { getAvailableUpdate } from "./update";
+
+async function refreshAvailableUpdate(state: TUIState): Promise<void> {
+  state.availableUpdate = await getAvailableUpdate();
+}
 
 function clearOrAbort(state: TUIState) {
   // Are we mid stream? Abort it.
@@ -45,55 +48,10 @@ function clearOrAbort(state: TUIState) {
   }
 }
 
-async function directoryExists(path: string): Promise<boolean> {
-  try {
-    return (await stat(path)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-async function handleSkillSlashCommand(prompt: string) {
-  const match = prompt.trim().match(/^\/([a-zA-Z0-9_-]+)(?:\s|$)/);
-
-  if (!match) return;
-
-  const skillName = match[1];
-  const skillRoots = [
-    join(homedir(), ".agents", "skills"),
-    join(process.cwd(), ".agents", "skills"),
-  ];
-
-  for (const root of skillRoots) {
-    if (!(await directoryExists(root))) {
-      continue;
-    }
-
-    const glob = new Bun.Glob("*/SKILL.md");
-
-    for await (const path of glob.scan({ cwd: root, absolute: true })) {
-      const file = Bun.file(path);
-
-      if (!(await file.exists())) {
-        continue;
-      }
-
-      const body = await file.text();
-      const frontmatter = body.match(/^---\s*\n([\s\S]*?)\n---/);
-      const name = frontmatter?.[1]
-        .match(/^name:\s*["']?([^"'\n]+)["']?\s*$/m)?.[1]
-        ?.trim();
-
-      if (name === skillName) {
-        return body;
-      }
-    }
-  }
-}
-
 export function initTUI(state: TUIState, leave: (s: string) => void) {
   // TODO: Cleanup accumulated sessions for this cwd.
   const { spinnerEvery, currentSpinner } = Spinner();
+  void refreshAvailableUpdate(state);
 
   // Stable 60fps rendering.
   // This ensure Xfps, and excessive calls get coalesced in cel-tui.
@@ -136,16 +94,6 @@ export function initTUI(state: TUIState, leave: (s: string) => void) {
     const submit = async () => {
       await streamAgentTUI(state);
     };
-    const skillSubmit = async () => {
-      const skill = await handleSkillSlashCommand(state.prompt);
-      if (skill) {
-        state.streaming = true;
-        // This cause the prompt to flash the body before vanishing on submit.
-        // To avoid this I added a new state property
-        state.promptSkill = skill;
-        await streamAgentTUI(state);
-      }
-    };
     // onKeyPress
     if (key === "enter") {
       if (state.prompt === ":q") {
@@ -164,17 +112,15 @@ export function initTUI(state: TUIState, leave: (s: string) => void) {
         state.stickToBottom = true;
         return false;
       }
-      if (state.prompt && state.prompt[0] === "/" && !state.streaming) {
-        skillSubmit();
-        return false;
-      }
       if (state.prompt && !state.streaming) submit();
       return false;
     }
   };
 
-  cel.init(new ProcessTerminal());
+  applyTUITheme(state.options.theme);
+  cel.init(new ProcessTerminal(), { theme: activeTuiTheme });
   cel.viewport(() => {
+    const activeTheme = getTUITheme(state.options.theme);
     const layers = [
       VStack(
         {
@@ -182,9 +128,12 @@ export function initTUI(state: TUIState, leave: (s: string) => void) {
           gap: 1,
           padding: { x: 1, y: 1 },
           onKeyPress: onWindowKeyPress,
+          fgColor: activeTheme.rootFgColor,
+          bgColor: activeTheme.rootBgColor,
+          italic: state.forceThemeRefresh,
         },
         [
-          state.messages.length ? Conversation(state) : emptyState(),
+          state.messages.length ? Conversation(state) : emptyState(state),
           HStack({ gap: 1 }, [
             ModelPill(state),
             TextPill(`../${state.cwd}`, theme.bwhite, theme.bblack),
@@ -221,12 +170,6 @@ async function streamAgentTUI(state: TUIState) {
   ];
 
   let userContent = state.prompt;
-  if (state.promptSkill) {
-    // TODO: Skill arguments? replace template marks in skill body for arguments?
-    //       Right now we just appead the user prompt to the skill body
-    userContent = `${state.promptSkill}\n${state.prompt}`;
-    state.promptSkill = undefined;
-  }
   if (state.messages.length === 0) {
     const envReminder = await injectEnvReminder();
     userContent = `${envReminder}\n\n${userContent}`;
@@ -351,6 +294,13 @@ async function streamAgentTUI(state: TUIState) {
         }
       }
     }
+  } catch (error) {
+    const text = error instanceof Error ? error.message : String(error);
+    state.tuiMessages.push({
+      timestamp: formatTimestamp(Date.now()),
+      role: "assistant",
+      text,
+    });
   } finally {
     state.streaming = false;
     if (!state.sessionId) {

package/src/types.ts

@@ -10,6 +10,7 @@ import {
   Type,
 } from "@earendil-works/pi-ai";
 import type { OAuthCredentials } from "@earendil-works/pi-ai/oauth";
+import { TUI_THEME_IDS, type TUIThemeId } from "./themes";
 
 const ThinkingLevelSchema = Type.Unsafe<ThinkingLevel>(
   Type.Union([
@@ -45,11 +46,16 @@ const ModelSchema = Type.Unsafe<Model<Api>>(
   }),
 );
 
+const TUIThemeIdSchema = Type.Unsafe<TUIThemeId>(
+  Type.Union(TUI_THEME_IDS.map((id) => Type.Literal(id))),
+);
+
 export const SettingsSchema = Type.Object({
   provider: Type.String(),
   model: Type.String(),
   effort: ThinkingLevelSchema,
   customProviders: Type.Optional(Type.Array(ModelSchema)),
+  theme: Type.Optional(TUIThemeIdSchema),
 });
 export type Settings = Static<typeof SettingsSchema>;
 
@@ -59,6 +65,7 @@ export const CliOptionsSchema = Type.Object({
   effort: ThinkingLevelSchema,
   prompt: Type.Optional(Type.String()),
   customProviders: Type.Optional(Type.Array(ModelSchema)),
+  theme: TUIThemeIdSchema,
 });
 export type CliOptions = Static<typeof CliOptionsSchema>;
 
@@ -91,10 +98,14 @@ export type TUIMessage = {
   toolCalls?: TUIToolCall[];
 };
 
+export type AvailableUpdate = {
+  currentVersion: string;
+  latestVersion: string;
+};
+
 export type TUIState = {
   options: CliOptions;
   prompt: string;
-  promptSkill?: string;
   messages: Message[]; // Context messages
   tuiMessages: TUIMessage[];
   contextSize?: number;
@@ -104,7 +115,9 @@ export type TUIState = {
   abortController?: AbortController;
   cwd: string;
   gitBranch?: string;
+  availableUpdate?: AvailableUpdate | undefined;
   overlay?: boolean | undefined;
+  forceThemeRefresh?: boolean | undefined;
   sessionId?: string | undefined;
 };
 

package/src/update.ts

@@ -0,0 +1,171 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+import { type Static, Type } from "@earendil-works/pi-ai";
+import { Value } from "typebox/value";
+
+import { DATA_DIR } from "./shared";
+import type { AvailableUpdate } from "./types";
+
+const PACKAGE_NAME = "mini-coder";
+const PACKAGE_MANIFEST_URL = new URL("../package.json", import.meta.url);
+const UPDATE_CHECK_CACHE_PATH = join(DATA_DIR, "update-check.json");
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_CHECK_TIMEOUT_MS = 5_000;
+
+const UpdateCheckCacheSchema = Type.Object({
+  checkedAt: Type.Number(),
+  currentVersion: Type.String(),
+  latestVersion: Type.Optional(Type.String()),
+});
+type UpdateCheckCache = Static<typeof UpdateCheckCacheSchema>;
+
+function parseLatestVersion(output: string): string | undefined {
+  const version = output.trim().split(/\s+/)[0];
+
+  if (!version || !isValidVersion(version)) {
+    return;
+  }
+
+  return version;
+}
+
+function isValidVersion(version: string): boolean {
+  try {
+    Bun.semver.order(version, version);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isNewerVersion(
+  currentVersion: string,
+  latestVersion: string,
+): boolean {
+  try {
+    return Bun.semver.order(latestVersion, currentVersion) === 1;
+  } catch {
+    return false;
+  }
+}
+
+function isFreshUpdateCheck(cache: UpdateCheckCache, now: number): boolean {
+  return now - cache.checkedAt < UPDATE_CHECK_INTERVAL_MS;
+}
+
+function getAvailableUpdateFromLatest(
+  currentVersion: string,
+  latestVersion: string | undefined,
+): AvailableUpdate | undefined {
+  if (!latestVersion || !isNewerVersion(currentVersion, latestVersion)) {
+    return;
+  }
+
+  return { currentVersion, latestVersion };
+}
+
+async function getCurrentVersion(): Promise<string | undefined> {
+  const manifest = (await Bun.file(PACKAGE_MANIFEST_URL).json()) as {
+    version?: unknown;
+  };
+
+  if (typeof manifest.version !== "string") {
+    return;
+  }
+
+  return manifest.version;
+}
+
+async function getLatestVersion(): Promise<string | undefined> {
+  try {
+    const proc = Bun.spawn(["bun", "pm", "view", PACKAGE_NAME, "version"], {
+      stdout: "pipe",
+      stderr: "ignore",
+      timeout: UPDATE_CHECK_TIMEOUT_MS,
+    });
+    const [stdout, exitCode] = await Promise.all([
+      proc.stdout.text(),
+      proc.exited,
+    ]);
+
+    if (exitCode !== 0) {
+      return;
+    }
+
+    return parseLatestVersion(stdout);
+  } catch {
+    return;
+  }
+}
+
+async function readUpdateCheckCache(): Promise<UpdateCheckCache | undefined> {
+  try {
+    const file = Bun.file(UPDATE_CHECK_CACHE_PATH);
+
+    if (!(await file.exists())) {
+      return;
+    }
+
+    const value = (await file.json()) as unknown;
+
+    if (!Value.Check(UpdateCheckCacheSchema, value)) {
+      return;
+    }
+
+    return value;
+  } catch {
+    return;
+  }
+}
+
+async function writeUpdateCheckCache(cache: UpdateCheckCache): Promise<void> {
+  try {
+    await mkdir(DATA_DIR, { recursive: true });
+    await Bun.write(UPDATE_CHECK_CACHE_PATH, JSON.stringify(cache, null, 2));
+  } catch {
+    // Update checks are best-effort and must never interrupt startup.
+  }
+}
+
+export async function getAvailableUpdate(): Promise<
+  AvailableUpdate | undefined
+> {
+  const currentVersion = await getCurrentVersion().catch(() => undefined);
+
+  if (!currentVersion) {
+    return;
+  }
+
+  const now = Date.now();
+  const cache = await readUpdateCheckCache();
+
+  if (cache && isFreshUpdateCheck(cache, now)) {
+    return getAvailableUpdateFromLatest(currentVersion, cache.latestVersion);
+  }
+
+  const latestVersion = await getLatestVersion();
+  await writeUpdateCheckCache({
+    checkedAt: now,
+    currentVersion,
+    latestVersion,
+  });
+
+  return getAvailableUpdateFromLatest(currentVersion, latestVersion);
+}
+
+export async function updateMiniCoder(): Promise<void> {
+  console.log("Updating mini-coder...");
+
+  const proc = Bun.spawn(["bun", "add", "-g", "mini-coder@latest"], {
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    throw new Error(`Update failed with exit code ${exitCode}`);
+  }
+
+  console.log("mini-coder updated.");
+}