mini-coder 0.5.14 → 0.6.0

package/src/args.ts

@@ -0,0 +1,289 @@
+import { mkdir } from "node:fs/promises";
+import {
+  type Api,
+  getModels,
+  getProviders,
+  type Model,
+  type ThinkingLevel,
+} from "@mariozechner/pi-ai";
+import { Value } from "typebox/value";
+import { getAvailableProviders, isOAuthProvider, loginOAuth } from "./oauth";
+import { DATA_DIR, SETTINGS_PATH } from "./shared.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();
+  const settings = JSON.parse(jsonText) as unknown;
+
+  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;
+}
+
+function findModelConfig(
+  modelId: string,
+  provider: string,
+  customProviders?: Model<Api>[],
+) {
+  const knownProviders = getProviders() as string[];
+  if (knownProviders.includes(provider)) {
+    const models = getModels(provider as any);
+    if (models.length === 0) throw new Error("Provider has no models");
+    return models.find((m) => m.id === modelId);
+  }
+  return customProviders?.find(
+    (m) => m.provider === provider && m.id === modelId,
+  );
+}
+
+function getFirstModelConfig(
+  provider: string,
+  customProviders?: Model<Api>[],
+): Model<Api> {
+  const knownProviders = getProviders() as string[];
+  if (knownProviders.includes(provider)) {
+    const models = getModels(provider as any);
+    if (models.length > 0) return models[0];
+  }
+  const custom = customProviders?.find((m) => m.provider === provider);
+  if (custom) return custom;
+  throw new Error("Provider has no models");
+}
+
+function getFallbackModel(
+  provider: string,
+  explicitModel: boolean,
+  providerChanged: boolean,
+  customProviders?: Model<Api>[],
+): Model<Api> {
+  if (explicitModel) {
+    throw new Error("Model not found");
+  }
+
+  if (!providerChanged) {
+    throw new Error("Model not found");
+  }
+
+  return getFirstModelConfig(provider, customProviders);
+}
+
+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;
+  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,
+  });
+  const nextSettings = parseSettings(
+    {
+      provider: options.provider,
+      model: options.model.id,
+      effort: options.effort,
+      customProviders,
+    },
+    "settings",
+  );
+
+  await saveSettings(nextSettings);
+  return options;
+}

package/src/headless.ts

@@ -1,365 +1,50 @@
-/**
- * Headless one-shot execution.
- *
- * @module
- */
-
-import type { AssistantMessage, UserMessage } from "@mariozechner/pi-ai";
-import type { AgentEvent } from "./agent.ts";
-import {
-  extractAssistantActivitySnippet,
-  extractAssistantErrorText,
-  extractAssistantText,
-} from "./assistant-output.ts";
-import type { AppState } from "./index.ts";
-import {
-  resolveRawInput,
-  type SubmitTurnHooks,
-  submitResolvedInput,
-} from "./submit.ts";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-type HeadlessStopReason = "stop" | "length" | "error" | "aborted";
-
-/** Options for a headless NDJSON run. */
-export interface HeadlessRunOptions {
-  /** Optional line writer for completed NDJSON event output. */
-  writeLine?: (line: string) => void | Promise<void>;
-}
-
-/** Options for a headless final-text run. */
-export interface HeadlessTextRunOptions {
-  /** Optional writer for lightweight assistant-activity snippets. */
-  writeActivity?: (text: string) => void | Promise<void>;
-  /** Optional writer for the final assistant text output. */
-  writeText?: (text: string) => void | Promise<void>;
-}
-
-interface HeadlessOutputController {
-  /** Queue text for one output stream with broken-pipe handling. */
-  write(text: string): void;
-  /** Attach error handlers for the active run. */
-  attach(): void;
-  /** Remove error handlers after the run. */
-  detach(): void;
-  /** Wait for queued writes and resolve the final stop reason. */
-  finalize(stopReason: HeadlessStopReason): Promise<HeadlessStopReason>;
-}
-
-interface HeadlessProcessStream {
-  /** Register an output-stream error handler. */
-  on(event: "error", listener: (error: unknown) => void): void;
-  /** Remove an output-stream error handler. */
-  off(event: "error", listener: (error: unknown) => void): void;
-  /** Write a text chunk to the stream. */
-  write(text: string, callback?: () => void): boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function defaultWrite(
-  stream: HeadlessProcessStream,
-  text: string,
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-
-    const cleanup = (): void => {
-      stream.off("error", handleError);
-    };
-
-    const settle = (callback: () => void): void => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      callback();
-    };
-
-    const handleError = (error: unknown): void => {
-      settle(() => {
-        reject(error);
-      });
-    };
-
-    stream.on("error", handleError);
-    try {
-      stream.write(text, () => {
-        settle(resolve);
-      });
-    } catch (error) {
-      settle(() => {
-        reject(error);
-      });
-    }
-  });
-}
-
-function isBrokenPipeError(error: unknown): boolean {
-  return (
-    typeof error === "object" &&
-    error !== null &&
-    (("code" in error && error.code === "EPIPE") ||
-      ("message" in error &&
-        typeof error.message === "string" &&
-        error.message.includes("broken pipe")))
-  );
-}
-
-function createSigintHandler(state: AppState): () => void {
-  return () => {
-    state.abortController?.abort();
-  };
-}
-
-function buildCommandError(command: string): Error {
-  return new Error(
-    `Headless mode does not support slash commands: /${command}`,
-  );
-}
-
-function resolveHeadlessContent(
-  state: AppState,
-  rawInput: string,
-): UserMessage["content"] {
-  const resolved = resolveRawInput(rawInput, state);
-  switch (resolved.type) {
-    case "empty":
-      throw new Error("Headless input is empty.");
-    case "error":
-      throw new Error(resolved.message);
-    case "command":
-      throw buildCommandError(resolved.command);
-    case "message":
-      return resolved.content;
-  }
-}
-
-function shouldWriteHeadlessJsonEvent(event: AgentEvent): boolean {
-  switch (event.type) {
-    case "user_message":
-    case "assistant_message":
-    case "tool_result":
-    case "done":
-    case "error":
-    case "aborted":
-      return true;
-    default:
-      return false;
-  }
-}
-
-function createHeadlessOutputController(
-  state: AppState,
-  stream: HeadlessProcessStream,
-  writeImpl: (text: string) => void | Promise<void>,
-  options?: {
-    attachSigint?: boolean;
-  },
-): HeadlessOutputController {
-  let brokenPipe = false;
-  let outputError: unknown = null;
-  let pendingWrite = Promise.resolve();
-  const sigintHandler = createSigintHandler(state);
-  const attachSigint = options?.attachSigint ?? true;
-
-  const stopForBrokenPipe = (): void => {
-    if (brokenPipe) {
-      return;
-    }
-    brokenPipe = true;
-    state.abortController?.abort();
-  };
-
-  const failOutput = (error: unknown): void => {
-    if (isBrokenPipeError(error)) {
-      stopForBrokenPipe();
-      return;
-    }
-
-    outputError = outputError ?? error;
-    state.abortController?.abort();
-  };
-
-  const streamErrorHandler = (error: unknown): void => {
-    failOutput(error);
-  };
-
-  return {
-    write(text) {
-      if (brokenPipe || outputError) {
-        return;
-      }
-
-      pendingWrite = pendingWrite.then(async () => {
-        if (brokenPipe || outputError) {
-          return;
-        }
-
-        try {
-          await writeImpl(text);
-        } catch (error) {
-          failOutput(error);
-        }
-      });
-    },
-    attach() {
-      stream.on("error", streamErrorHandler);
-      if (attachSigint) {
-        process.on("SIGINT", sigintHandler);
-      }
+import type { Message } from "@mariozechner/pi-ai";
+import { streamAgent } from "./agent";
+import { buildSystemPrompt, injectEnvReminder, MAIN_PROMPT } from "./prompt";
+import { bash, runBashTool } from "./tool-bash";
+import { edit, runEditTool } from "./tool-edit";
+import { runTaskTool, task } from "./tool-task";
+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: task,
+      runner: (args) => runTaskTool(options, args),
     },
-    detach() {
-      stream.off("error", streamErrorHandler);
-      if (attachSigint) {
-        process.off("SIGINT", sigintHandler);
-      }
-    },
-    async finalize(stopReason) {
-      await pendingWrite;
-      if (outputError) {
-        throw outputError;
-      }
-      return brokenPipe ? "stop" : stopReason;
-    },
-  };
-}
-
-/**
- * Run a single headless prompt to completion and stream completed NDJSON events.
- *
- * The raw input is parsed with the same rules as interactive input. Slash
- * commands are rejected in headless mode. Persisted messages and terminal
- * events are written as one JSON object per line; streaming delta/progress
- * events are omitted.
- *
- * @param state - Mutable application state for the run.
- * @param rawInput - Exact raw prompt text supplied by the user.
- * @param options - Optional event-output overrides.
- * @returns The terminal stop reason for the agent loop.
- */
-export async function runHeadlessPrompt(
-  state: AppState,
-  rawInput: string,
-  options?: HeadlessRunOptions,
-): Promise<HeadlessStopReason> {
-  const content = resolveHeadlessContent(state, rawInput);
-  const output = createHeadlessOutputController(
-    state,
-    process.stdout,
-    options?.writeLine ?? ((line) => defaultWrite(process.stdout, `${line}\n`)),
-  );
-  const hooks: SubmitTurnHooks = {
-    onEvent: (event) => {
-      if (!shouldWriteHeadlessJsonEvent(event)) {
-        return;
-      }
-      output.write(JSON.stringify(event));
+  ];
+  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,
   };
 
-  output.attach();
-  try {
-    const stopReason = await submitResolvedInput(
-      rawInput,
-      content,
-      state,
-      hooks,
-    );
-    return await output.finalize(stopReason);
-  } finally {
-    output.detach();
-  }
-}
-
-/**
- * Run a single headless prompt to completion and write the final assistant text.
- *
- * The raw input is parsed with the same rules as interactive input. Slash
- * commands are rejected in headless mode. The final assistant text is written
- * to stdout, while lightweight assistant commentary snippets from tool-use
- * turns and terminal assistant error messages are written to stderr.
- *
- * @param state - Mutable application state for the run.
- * @param rawInput - Exact raw prompt text supplied by the user.
- * @param options - Optional final-text output overrides.
- * @returns The terminal stop reason for the agent loop.
- */
-export async function runHeadlessPromptText(
-  state: AppState,
-  rawInput: string,
-  options?: HeadlessTextRunOptions,
-): Promise<HeadlessStopReason> {
-  const content = resolveHeadlessContent(state, rawInput);
-  const finalOutput = createHeadlessOutputController(
-    state,
-    process.stdout,
-    options?.writeText ?? ((text) => defaultWrite(process.stdout, text)),
-  );
-  const activityOutput = createHeadlessOutputController(
-    state,
-    process.stderr,
-    options?.writeActivity ?? ((text) => defaultWrite(process.stderr, text)),
-    { attachSigint: false },
-  );
-  let finalAssistantMessage: AssistantMessage | null = null;
-  const hooks: SubmitTurnHooks = {
-    onEvent: (event) => {
-      switch (event.type) {
-        case "assistant_message": {
-          const activitySnippet = extractAssistantActivitySnippet(
-            event.message,
-          );
-          if (activitySnippet) {
-            activityOutput.write(`${activitySnippet}\n`);
-          }
-          return;
-        }
-        case "done":
-        case "error":
-        case "aborted":
-          finalAssistantMessage = event.message;
-          return;
-        default:
-          return;
-      }
-    },
-  };
-
-  finalOutput.attach();
-  activityOutput.attach();
-  try {
-    const stopReason = await submitResolvedInput(
-      rawInput,
-      content,
-      state,
-      hooks,
-    );
-    const finalText = extractAssistantText(finalAssistantMessage);
-    if (finalText.length > 0) {
-      finalOutput.write(finalText);
+  const agent = streamAgent(ctx);
+  for await (const ev of agent) {
+    switch (ev.type) {
+      case "message_end":
+      case "tool_message_end":
+        console.log(JSON.stringify(ev.message));
+        break;
     }
-
-    const terminalErrorText = extractAssistantErrorText(finalAssistantMessage);
-    if (terminalErrorText) {
-      activityOutput.write(`${terminalErrorText}\n`);
-    }
-
-    const [finalStopReason, activityStopReason] = await Promise.all([
-      finalOutput.finalize(stopReason),
-      activityOutput.finalize(stopReason),
-    ]);
-    return finalStopReason === "stop" || activityStopReason === "stop"
-      ? "stop"
-      : stopReason;
-  } finally {
-    activityOutput.detach();
-    finalOutput.detach();
   }
+
+  leave();
 }