mini-coder 0.7.4 → 0.8.0

package/src/args.ts

@@ -1,252 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import type { ThinkingLevel } from "@earendil-works/pi-ai";
-import { Value } from "typebox/value";
-import {
-  findModelConfig,
-  getFallbackModel,
-  getFirstModelConfig,
-} from "./models.ts";
-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,
-  type Settings,
-  SettingsSchema,
-} from "./types.ts";
-
-const DEFAULT_PROVIDER = "openai-codex";
-const DEFAULT_MODEL_ID = "gpt-5.5";
-const DEFAULT_EFFORT: ThinkingLevel = "xhigh";
-
-function formatValidationError(
-  label: string,
-  error: ReturnType<typeof Value.Errors>[number] | undefined,
-) {
-  if (!error) {
-    return `Invalid ${label}`;
-  }
-
-  const path = error.instancePath || "/";
-  return `Invalid ${label}: ${path} ${error.message}`;
-}
-
-function parseSettings(value: unknown, label: string): Settings {
-  if (Value.Check(SettingsSchema, value)) {
-    return value;
-  }
-
-  throw new Error(
-    formatValidationError(label, Value.Errors(SettingsSchema, value)[0]),
-  );
-}
-
-function parseCliOptions(value: unknown): CliOptions {
-  if (Value.Check(CliOptionsSchema, value)) {
-    return value;
-  }
-
-  throw new Error(
-    formatValidationError(
-      "CLI options",
-      Value.Errors(CliOptionsSchema, value)[0],
-    ),
-  );
-}
-
-async function getSettings(): Promise<Settings | undefined> {
-  const file = Bun.file(SETTINGS_PATH);
-
-  if (!(await file.exists())) {
-    return;
-  }
-
-  const jsonText = await file.text();
-  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");
-}
-
-export async function saveSettings(s: Settings) {
-  await mkdir(DATA_DIR, { recursive: true });
-  const file = Bun.file(SETTINGS_PATH);
-  await Bun.write(file, JSON.stringify(s, null, 4));
-}
-
-function requireValue(argv: string[], index: number, flag: string) {
-  const value = argv[index + 1];
-
-  if (!value || value.startsWith("-")) {
-    throw new Error(`${flag} requires a value`);
-  }
-
-  return value;
-}
-
-export async function handleArgv(argv: string[]): Promise<CliOptions> {
-  const settings = await getSettings();
-  const customProviders = settings?.customProviders ?? [];
-  const builtInProviders = await getAvailableProviders();
-  const availableProviders = [
-    ...new Set([
-      ...builtInProviders,
-      ...customProviders.map((cp) => cp.provider),
-    ]),
-  ];
-  const defaultProvider = availableProviders[0] ?? DEFAULT_PROVIDER;
-  const settingsProvider = settings?.provider ?? defaultProvider;
-  const settingsModelId =
-    settings?.model ??
-    (settingsProvider === DEFAULT_PROVIDER
-      ? 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;
-  let prompt: string | undefined;
-  let providerChanged = false;
-  let explicitProvider = false;
-  let explicitModel = false;
-
-  for (let i = 0; i < argv.length; i++) {
-    const flag = argv[i];
-
-    // Settings
-    if (flag === "--provider") {
-      provider = parseSettings(
-        {
-          provider: requireValue(argv, i, flag),
-          model: modelId,
-          effort,
-        },
-        "CLI settings",
-      ).provider;
-      providerChanged = provider !== settingsProvider;
-      explicitProvider = true;
-      i++;
-      continue;
-    }
-
-    if (flag === "--model") {
-      modelId = requireValue(argv, i, flag);
-      explicitModel = true;
-      i++;
-      continue;
-    }
-
-    if (flag === "--effort") {
-      effort = parseSettings(
-        {
-          provider,
-          model: modelId,
-          effort: requireValue(argv, i, flag),
-        },
-        "CLI settings",
-      ).effort;
-      i++;
-      continue;
-    }
-
-    // headless api
-    if (flag === "--prompt" || flag === "-p") {
-      prompt = requireValue(argv, i, flag);
-      i++;
-      continue;
-    }
-
-    if (flag === "--login" || flag === "-l") {
-      await loginOAuth(requireValue(argv, i, flag));
-      // Rebuild available providers after login
-      const refreshedProviders = await getAvailableProviders();
-      availableProviders.splice(
-        0,
-        availableProviders.length,
-        ...new Set([
-          ...refreshedProviders,
-          ...customProviders.map((cp) => cp.provider),
-        ]),
-      );
-      i++;
-    }
-  }
-
-  let cliSettings = parseSettings(
-    {
-      provider,
-      model: modelId,
-      effort,
-    },
-    "CLI settings",
-  );
-  const providerAvailable = availableProviders.includes(cliSettings.provider);
-
-  if (explicitProvider) {
-    if (!providerAvailable && !isOAuthProvider(cliSettings.provider)) {
-      throw new Error(
-        `Provider "${cliSettings.provider}" is not logged in and no API key was found`,
-      );
-    }
-  } else if (!providerAvailable && availableProviders.length) {
-    const fallbackProvider = availableProviders[0];
-    provider = fallbackProvider;
-    providerChanged = provider !== settingsProvider;
-    if (!explicitModel) {
-      modelId = getFirstModelConfig(fallbackProvider, customProviders).id;
-    }
-
-    cliSettings = parseSettings(
-      {
-        provider,
-        model: modelId,
-        effort,
-      },
-      "CLI settings",
-    );
-  }
-
-  const selectedModel = findModelConfig(
-    cliSettings.model,
-    cliSettings.provider,
-    customProviders,
-  );
-  const model =
-    selectedModel ??
-    getFallbackModel(
-      cliSettings.provider,
-      explicitModel,
-      providerChanged,
-      customProviders,
-    );
-
-  const options = parseCliOptions({
-    provider: cliSettings.provider,
-    model,
-    effort: cliSettings.effort,
-    prompt,
-    customProviders,
-    theme: settingsTheme,
-  });
-  const nextSettings = parseSettings(
-    {
-      provider: options.provider,
-      model: options.model.id,
-      effort: options.effort,
-      customProviders,
-      theme: options.theme,
-    },
-    "settings",
-  );
-
-  await saveSettings(nextSettings);
-  return options;
-}

package/src/error-handling.test.ts

@@ -1,163 +0,0 @@
-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/git.ts

@@ -1,23 +0,0 @@
-import simpleGit from "simple-git";
-
-const git = simpleGit();
-
-export async function getGitStatus() {
-  try {
-    const status = await git.status();
-    return status;
-  } catch (_) {
-    return { nogit: "No git repo in this folder." };
-  } // No git
-}
-
-export async function getBranchLabel() {
-  try {
-    const status = await git.status();
-    const isClean = status.isClean();
-
-    return `${status.current}${isClean ? "" : "*"}`;
-  } catch (_) {
-    return "No git";
-  } // No git
-}

package/src/headless.ts

@@ -1,66 +0,0 @@
-import type { Message } from "@earendil-works/pi-ai";
-import { streamAgent } from "./agent";
-import {
-  buildSystemPrompt,
-  injectEnvReminder,
-  insertToolUsageReminder,
-  MAIN_PROMPT,
-} from "./prompt";
-import { bash, runBashTool } from "./tool-bash";
-import { edit, runEditTool } from "./tool-edit";
-import { read, runReadTool } from "./tool-read";
-import type { AgentContex, CliOptions, ToolAndRunner } from "./types";
-
-export async function streamHeadless(
-  options: CliOptions,
-  leave: (s?: string) => void,
-) {
-  const tools: ToolAndRunner[] = [
-    { tool: bash, runner: runBashTool },
-    { tool: edit, runner: runEditTool },
-    { tool: read, runner: runReadTool },
-  ];
-  const envReminder = await injectEnvReminder();
-  const messages: Message[] = [
-    {
-      role: "user",
-      content: `${envReminder}\n\n${options.prompt || ""}`,
-      timestamp: Date.now(),
-    },
-  ];
-  console.log(JSON.stringify(messages[0]));
-
-  const systemPrompt = await buildSystemPrompt(MAIN_PROMPT);
-  const ctx: AgentContex = {
-    systemPrompt,
-    tools,
-    messages,
-    options,
-  };
-
-  const agent = streamAgent(ctx);
-
-  for await (const ev of agent) {
-    switch (ev.type) {
-      case "message_end":
-        console.log(JSON.stringify(ev.message));
-        break;
-
-      case "tool_message_end": {
-        const withReminder = insertToolUsageReminder(messages, ev.message);
-        const idx = messages.findIndex(
-          (m) =>
-            m.role === "toolResult" && m.toolCallId === withReminder.toolCallId,
-        );
-        if (idx >= 0) {
-          messages[idx] = withReminder;
-        }
-
-        console.log(JSON.stringify(withReminder));
-        break;
-      }
-    }
-  }
-
-  leave();
-}

package/src/index.ts

@@ -1,43 +0,0 @@
-import { basename } from "node:path";
-import { handleArgv } from "./args.ts";
-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(argv);
-
-  function leave(msg?: string) {
-    if (msg) console.log(msg);
-    process.exit(0);
-  }
-
-  if (options.prompt) {
-    await streamHeadless(options, leave);
-    process.exit(0);
-  }
-
-  const state: TUIState = {
-    options,
-    prompt: "",
-    messages: [],
-    tuiMessages: [],
-    streaming: false,
-    stickToBottom: true,
-    scrollOffset: 0,
-    cwd,
-    gitBranch: await getBranchLabel(),
-  };
-
-  initTUI(state, leave);
-}