@synmux/claude-commit 1.0.3 → 1.1.0

package/src/types.ts

@@ -1,238 +0,0 @@
-/**
- * Shared types for claude-commit.
- */
-
-/**
- * Which models to use for each stage of the pipeline.
- *
- * A bare name (`sonnet`, `haiku`, a full `claude-*` id) runs through the
- * Claude Agent SDK. An `ollama:`-prefixed name runs against a local or
- * self-hosted Ollama server instead, with everything after the prefix taken
- * as the Ollama model name verbatim - tag included, so
- * `ollama:ornith-1.5:35b` means the model `ornith-1.5:35b`. The two stages
- * are resolved independently, so mixing providers is normal.
- */
-export interface ModelConfig {
-  /** Model used to read diffs and write summaries. Defaults to `sonnet`. */
-  summary: string;
-  /** Model used to turn summaries into the final commit message. Defaults to `sonnet`. */
-  final: string;
-}
-
-/** Settings for the Ollama backend, used only by `ollama:`-prefixed models. */
-export interface OllamaConfig {
-  /**
-   * Base URL of the Ollama server. Defaults to `$OLLAMA_HOST`, falling back
-   * to `http://localhost:11434`. A bare `host:port` (Ollama's own
-   * convention for that variable) is given an `http://` scheme.
-   */
-  host: string;
-  /**
-   * Context window requested for every Ollama call (`options.num_ctx`) and
-   * used to size diff chunks: a token count, or `"auto"` (the default) to
-   * take the window Ollama itself chooses for the model on this machine.
-   *
-   * The window is always sent explicitly, never left to the server: a
-   * prompt over it is truncated *silently* - HTTP 200, oldest content
-   * dropped, no flag on the response - and a summary written from half a
-   * diff is worse than an error, so cco pins the number it sized its chunks
-   * against and cross-checks the response's token counts.
-   *
-   * `"auto"` asks Ollama rather than guessing: the model is preloaded with
-   * no `num_ctx`, which makes the server pick from its VRAM tiers (4k / 32k
-   * / 256k, capped at the model's trained maximum), and the choice is read
-   * back from `/api/ps`. That is the largest window the server believes
-   * this machine can run, resolved once per model per run. A number pins
-   * the window instead - lower it when memory is tight (memory scales with
-   * it, multiplied by `OLLAMA_NUM_PARALLEL`), or raise it past the tier if
-   * you know better than the server does.
-   */
-  context: number | "auto";
-  /**
-   * How long the server keeps the model loaded after a request: a duration
-   * string (`"10m"`), seconds as a number, `0` to unload immediately, or a
-   * negative value to pin it. `null` leaves the server's own default (which
-   * is itself 5 minutes unless `OLLAMA_KEEP_ALIVE` says otherwise).
-   */
-  keepAlive: string | number | null;
-}
-
-/** Fully-resolved configuration after merging defaults, file config and CLI flags. */
-export interface Config {
-  /** Format the subject line as a Conventional Commit (`type(scope): description`). */
-  conventionalCommits: boolean;
-  /** Prefix the subject line with a gitmoji. */
-  gitmoji: boolean;
-  /** Produce a multi-line commit (subject + body) instead of a single subject line. */
-  multiline: boolean;
-  /**
-   * Template for the first line. `{message}` is replaced with the generated
-   * subject. Useful for ticket prefixes, e.g. `"[PROJ-123] {message}"`.
-   */
-  template: string | null;
-  /** Extra instructions appended to the standard prompt. */
-  customPrompt: string | null;
-  /**
-   * Default to interactive mode (the `-i` selection TUI) on every run, without
-   * needing to pass `-i`. Override for a single run with `--no-interactive`.
-   * When there is no interactive terminal (a pipe, CI, etc.) this is ignored and
-   * cco falls back to the non-interactive flow rather than failing.
-   */
-  interactive: boolean;
-  /** How many candidate messages to generate in interactive mode. */
-  interactiveCount: number;
-  /**
-   * Sampling temperature for the final model when generating interactive
-   * options, to encourage variety between candidates. `null` leaves the model
-   * at its default. Only applied in interactive mode.
-   */
-  interactiveTemperature: number | null;
-  /**
-   * Name of the progress spinner animation: any spinner from the cli-spinners
-   * set bundled with ora (e.g. `"dots"`, `"moon"`, `"material"`). Unknown
-   * names are ignored and the default is used instead.
-   */
-  spinner: string;
-  /** Models for each pipeline stage. */
-  models: ModelConfig;
-  /**
-   * Approximate maximum number of tokens of diff to send to the summary model
-   * in a single request. Diffs larger than this are split across requests.
-   */
-  maxChunkTokens: number;
-  /** Approximate characters-per-token ratio used for chunk-size estimation. */
-  charsPerToken: number;
-  /**
-   * Replace runs of armored/encoded diff lines (age/gpg armor, base64 blobs,
-   * git binary patch bodies) with a one-line `[... lines omitted]` marker
-   * before summarizing. Ciphertext is unreadable to the model and tokenizes
-   * at roughly one token per character, so skipping it makes commits in
-   * encrypted-file repos (e.g. chezmoi with age) fast and cheap without
-   * losing anything a summary could actually use.
-   */
-  skipArmored: boolean;
-  /**
-   * Gitignore-style patterns for paths whose changes matter less than the
-   * rest of the commit: generated docs, lockfiles, vendored snapshots, build
-   * output. Diff sections under these paths are summarised separately and
-   * briefly, and the final model is told to describe the other changes in
-   * the subject line and to mention these only after them. When every
-   * changed file matches, the changes are described normally - there is
-   * nothing else for them to yield to. A pattern containing `/` matches a
-   * path or any ancestor directory; a bare pattern matches any path segment
-   * (see `src/paths.ts`).
-   */
-  lowPriorityPaths: string[];
-  /**
-   * Gitignore-style patterns - the same language as `lowPriorityPaths` - for
-   * paths whose changes should not be read at all: vendored dependency
-   * trees, generated clients, bulk data fixtures. Matching diff sections are
-   * dropped before anything else looks at the diff, so they cost no tokens
-   * and cannot influence the message.
-   *
-   * The files are still committed; this governs only what the model reads.
-   * When every changed file matches, there is nothing left to describe and
-   * the run stops with an error naming the directive - unlike
-   * `lowPriorityPaths`, which promotes its partition in that case, because
-   * "this matters less" can degrade gracefully and "do not look at this"
-   * cannot.
-   */
-  ignore: string[];
-  /** Settings for the Ollama backend (`ollama:`-prefixed models). */
-  ollama: OllamaConfig;
-  /**
-   * Allow API credentials from the environment (`ANTHROPIC_API_KEY` /
-   * `ANTHROPIC_AUTH_TOKEN`) to be used, billing pay-as-you-go instead of the
-   * Claude subscription. When false (the default) those variables are
-   * stripped from the environment passed to the Claude Agent SDK subprocess,
-   * so an exported key can never silently switch billing.
-   */
-  allowApiKey: boolean;
-}
-
-/** Partial config as it may appear in a config file or be produced by flags. */
-export type PartialConfig = {
-  [K in keyof Config]?: K extends "models"
-    ? Partial<ModelConfig>
-    : K extends "ollama"
-      ? Partial<OllamaConfig>
-      : Config[K];
-};
-
-/**
- * How much weight a slice of the diff carries in the commit message.
- * `primary` changes define the commit; `low` changes - those under the
- * configured `lowPriorityPaths` - are summarised briefly and mentioned only
- * after the primary ones.
- */
-export type ChangePriority = "primary" | "low";
-
-/** The summary of one diff chunk, tagged with the priority of the partition it came from. */
-export interface DiffSummary {
-  priority: ChangePriority;
-  text: string;
-}
-
-/** Result of a single model invocation. */
-export interface ModelResult {
-  /** The text the model produced. */
-  text: string;
-  /** Cost of the call in USD, if reported. */
-  costUsd: number;
-  /** The model that actually served the request, if reported. */
-  model?: string;
-  /** Parsed structured output, when a JSON-schema `outputFormat` was requested. */
-  structured?: unknown;
-}
-
-/** A staged change as seen by `git`. */
-export interface FileChange {
-  /** Status code from `git diff --name-status` (e.g. `A`, `M`, `D`, `R100`). */
-  status: string;
-  /** Path of the file (the destination path for renames). */
-  path: string;
-}
-
-/**
- * One prompt to one model, whichever provider serves it.
- *
- * `model` carries the provider: bare names go to Claude, `ollama:`-prefixed
- * ones to Ollama (see {@link ModelConfig}). Some options only apply to one
- * provider - `allowApiKey` gates Claude credentials, `ollama` supplies the
- * host and context window - and each is simply ignored by the other.
- */
-export interface RunPromptOptions {
-  /** Model string: an alias (`sonnet`), a full id, or `ollama:<name>[:<tag>]`. */
-  model: string;
-  /** Full custom system prompt. */
-  system: string;
-  /** Receives assistant text as it streams in (enables partial messages). */
-  onText?: (delta: string) => void;
-  /** Abort the in-flight request. */
-  abortController?: AbortController;
-  /** Receives the underlying CLI's stderr (for `--verbose`). Claude only. */
-  onStderr?: (data: string) => void;
-  /**
-   * Sampling temperature. Used to add variety when generating several
-   * interactive options. Models that don't accept a temperature override
-   * will reject the request, so the caller should be prepared to retry
-   * without it.
-   */
-  temperature?: number;
-  /**
-   * Request a structured JSON response matching this schema. The parsed object
-   * is returned on {@link ModelResult.structured}. Models that don't support
-   * structured outputs will reject the request or return unparseable content,
-   * so the caller should be prepared to retry without it.
-   */
-  outputFormat?: { type: "json_schema"; schema: Record<string, unknown> };
-  /**
-   * Allow API credentials from the environment to reach the Claude Agent SDK
-   * subprocess. Defaults to false: `ANTHROPIC_API_KEY` /
-   * `ANTHROPIC_AUTH_TOKEN` are stripped so the run is billed to the Claude
-   * subscription. Has no meaning for Ollama, which takes no credential.
-   */
-  allowApiKey?: boolean;
-  /** Ollama host and context settings; required for an `ollama:` model. */
-  ollama?: OllamaConfig;
-}

package/src/ui/editor.ts

@@ -1,89 +0,0 @@
-/**
- * Launching the user's `$EDITOR` to tweak a commit message, plus a tiny
- * yes/no/edit confirmation prompt for non-interactive runs in a TTY.
- */
-import { spawn } from "node:child_process";
-import { readFile, unlink, writeFile } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { createInterface } from "node:readline";
-import { ClaudeCommitError } from "../errors";
-
-/** Resolve the editor command, mirroring git's lookup order. */
-function resolveEditor(): string {
-  return (
-    process.env.GIT_EDITOR || process.env.VISUAL || process.env.EDITOR || "vi"
-  );
-}
-
-/** Open `initial` in the user's editor and return the saved contents. */
-export async function editInEditor(initial: string): Promise<string> {
-  const editor = resolveEditor();
-  // Unpredictable name + exclusive create (`wx`) + owner-only perms (0o600)
-  // so the temp file can't be pre-created as a symlink or read by other users.
-  const file = join(tmpdir(), `claude-commit-edit-${randomUUID()}.txt`);
-  try {
-    await writeFile(file, initial, { mode: 0o600, flag: "wx" });
-  } catch (err) {
-    throw new ClaudeCommitError(
-      `Could not create a temporary file to edit the message: ${(err as Error).message}`,
-    );
-  }
-  try {
-    await runEditor(editor, file);
-    const edited = await readFile(file, "utf8");
-    // Drop trailing whitespace/newline noise editors tend to add.
-    return edited.replace(/\s+$/, "");
-  } catch (err) {
-    if (err instanceof ClaudeCommitError) throw err;
-    throw new ClaudeCommitError(
-      `Editing the commit message failed (${editor}): ${(err as Error).message}`,
-    );
-  } finally {
-    await unlink(file).catch(() => {});
-  }
-}
-
-function runEditor(editor: string, file: string): Promise<void> {
-  return new Promise((resolvePromise, reject) => {
-    // $EDITOR / $GIT_EDITOR are shell command lines that may contain flags,
-    // spaces in the program path, or quoted arguments (e.g. "code --wait" or
-    // "/path/with spaces/editor"). Run them through the shell exactly as git
-    // does rather than naively splitting on whitespace. The file path is our
-    // own (tmpdir + UUID), so double-quoting it is safe.
-    const child = spawn(`${editor} "${file}"`, {
-      stdio: "inherit",
-      shell: true,
-    });
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code === 0 || code === null) resolvePromise();
-      else reject(new Error(`Editor exited with code ${code}`));
-    });
-  });
-}
-
-export type ConfirmChoice = "yes" | "no" | "edit";
-
-/** Prompt for [Y]es / [n]o / [e]dit. Requires an interactive stdin. */
-export async function confirmCommit(): Promise<ConfirmChoice> {
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
-  try {
-    for (;;) {
-      const answer = (
-        await new Promise<string>((res) =>
-          rl.question("Commit this message? [Y/n/e] ", res),
-        )
-      )
-        .trim()
-        .toLowerCase();
-      if (answer === "" || answer === "y" || answer === "yes") return "yes";
-      if (answer === "n" || answer === "no") return "no";
-      if (answer === "e" || answer === "edit") return "edit";
-      process.stderr.write("Please answer y, n, or e.\n");
-    }
-  } finally {
-    rl.close();
-  }
-}

package/src/ui/interactive.ts

@@ -1,313 +0,0 @@
-/**
- * Interactive mode: generate several candidate messages, then let the user pick
- * one (and optionally edit it) before committing.
- *
- * The picker is an OpenTUI selection screen. All key handling is driven through
- * the renderer's global key handler so there is a single source of truth for
- * navigation. If the TUI cannot be initialized for any reason, we transparently
- * fall back to a plain readline prompt.
- */
-import { createInterface } from "node:readline";
-import { commit } from "../git";
-import { generateCommit } from "../generate";
-import { Spinner } from "./spinner";
-import { editInEditor } from "./editor";
-import { color } from "./colors";
-import type { Config } from "../types";
-
-export interface InteractiveOptions {
-  verbose: boolean;
-  abortController: AbortController;
-}
-
-type Selection =
-  { action: "commit" | "edit"; index: number } | { action: "cancel" };
-
-/** Run the full interactive flow. Returns a process exit code. */
-export async function runInteractive(
-  diff: string,
-  config: Config,
-  opts: InteractiveOptions,
-): Promise<number> {
-  const count = Math.max(1, config.interactiveCount);
-  const spinner = new Spinner(process.stderr.isTTY, config.spinner);
-  spinner.start(`Generating ${count} option${count === 1 ? "" : "s"}`);
-  let result;
-  try {
-    result = await generateCommit(diff, config, {
-      count,
-      progress: { onPhase: (label) => spinner.update(label) },
-      abortController: opts.abortController,
-    });
-  } catch (err) {
-    spinner.stop();
-    throw err;
-  }
-  spinner.stop();
-
-  const messages = result.messages;
-
-  let selection: Selection;
-  try {
-    selection = await selectWithTui(messages);
-  } catch {
-    // TUI failed to initialize (unusual terminal, etc.) - degrade gracefully.
-    selection = await selectWithReadline(messages);
-  }
-
-  if (selection.action === "cancel") {
-    process.stderr.write("Aborted. Nothing was committed.\n");
-    return 1;
-  }
-
-  let message = messages[selection.index]!;
-  if (selection.action === "edit") {
-    message = await editInEditor(message);
-    if (message.trim() === "") {
-      process.stderr.write("Aborted: empty commit message.\n");
-      return 1;
-    }
-  }
-
-  await commit(message);
-  process.stderr.write(
-    `${color("32", "✔")} Committed\n${color("90", firstLine(message))}\n`,
-  );
-  if (opts.verbose) {
-    process.stderr.write(
-      color("90", `cost $${result.costUsd.toFixed(4)}`) + "\n",
-    );
-  }
-  return 0;
-}
-
-/**
- * Rows a single candidate occupies in the picker: the subject line plus a
- * one-line body preview (`showDescription`), with OpenTUI's default
- * `itemSpacing` of 0. Mirrors SelectRenderable's own line accounting.
- */
-const PICKER_LINES_PER_ITEM = 2;
-
-/**
- * Rows reserved for the non-picker chrome when capping its height: root padding
- * (2), the header line (1) and the gap below it (1).
- */
-const PICKER_CHROME_ROWS = 4;
-
-/**
- * The picker's height, sized to its content (two rows per candidate) but capped
- * to the terminal so a large `interactiveCount` still fits; past the cap the list
- * scrolls internally (see `showScrollIndicator` in {@link buildPickerScene}). An
- * explicit height keeps the picker compact - only as tall as the options need -
- * rather than stretching to fill the screen.
- */
-export function pickerHeight(count: number, terminalRows: number): number {
-  const wanted = Math.max(1, count) * PICKER_LINES_PER_ITEM;
-  const cap = Math.max(
-    PICKER_LINES_PER_ITEM,
-    terminalRows - PICKER_CHROME_ROWS,
-  );
-  return Math.min(wanted, cap);
-}
-
-/** The `@opentui/core` module, however it is obtained (dynamic import or test). */
-type TuiModule = typeof import("@opentui/core");
-/** The renderer object returned by `createCliRenderer` (and the headless test renderer). */
-type TuiRenderer = Awaited<ReturnType<TuiModule["createCliRenderer"]>>;
-
-/** The renderables the caller wires key handling to after building the scene. */
-export interface PickerScene {
-  root: InstanceType<TuiModule["BoxRenderable"]>;
-  select: InstanceType<TuiModule["SelectRenderable"]>;
-}
-
-/**
- * Build the picker's renderable tree: a header line above the candidate list.
- * Extracted from {@link selectWithTui} so the layout can be rendered under
- * OpenTUI's headless test renderer and asserted on. The caller adds `root` to
- * the renderer and wires key handling to the returned `select`.
- */
-export function buildPickerScene(
-  renderer: TuiRenderer,
-  tui: TuiModule,
-  messages: string[],
-  terminalRows: number,
-): PickerScene {
-  const { BoxRenderable, TextRenderable, SelectRenderable } = tui;
-
-  const root = new BoxRenderable(renderer, {
-    flexDirection: "column",
-    width: "100%",
-    height: "100%",
-    padding: 1,
-    gap: 1,
-  });
-
-  const header = new TextRenderable(renderer, {
-    content:
-      "Pick a commit message   ↑/↓ select · ⏎ commit · e edit · q cancel",
-  });
-
-  // A compact, content-sized list of the candidate messages. flexShrink:0 keeps
-  // it at its full height; showScrollIndicator covers more options than fit.
-  const select = new SelectRenderable(renderer, {
-    height: pickerHeight(messages.length, terminalRows),
-    flexShrink: 0,
-    showScrollIndicator: true,
-    options: messages.map((message, index) => ({
-      name: firstLine(message),
-      description: bodyPreview(message),
-      value: index,
-    })),
-    selectedIndex: 0,
-    showDescription: true,
-    wrapSelection: true,
-    // A calm slate highlight (OpenTUI's own default background) with soft
-    // near-white text - the previous bright cyan/black fill was too harsh.
-    // The default description greys (#888888 / #CCCCCC) read fine on the slate,
-    // so they are left untouched.
-    selectedBackgroundColor: "#334455",
-    selectedTextColor: "#e6edf3",
-  });
-
-  root.add(header);
-  root.add(select);
-
-  return { root, select };
-}
-
-/** The OpenTUI selection screen. Resolves with the user's choice. */
-async function selectWithTui(messages: string[]): Promise<Selection> {
-  const tui = await import("@opentui/core");
-  const renderer = await tui.createCliRenderer({ exitOnCtrlC: false });
-
-  return await new Promise<Selection>((resolve, reject) => {
-    let settled = false;
-    let onKey: (key: { name?: string; ctrl?: boolean }) => void = () => {};
-
-    const cleanup = () => {
-      try {
-        renderer.keyInput.off("keypress", onKey);
-      } catch {
-        /* ignore */
-      }
-      try {
-        renderer.destroy();
-      } catch {
-        /* ignore */
-      }
-    };
-    const finish = (sel: Selection) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      resolve(sel);
-    };
-
-    try {
-      const terminalRows = process.stdout.rows ?? 24;
-      const { root, select } = buildPickerScene(
-        renderer,
-        tui,
-        messages,
-        terminalRows,
-      );
-      renderer.root.add(root);
-
-      onKey = (key) => {
-        if (!key) return; // some terminals can emit empty/unknown key events
-        try {
-          switch (key.name) {
-            case "up":
-            case "k":
-              select.moveUp();
-              renderer.requestRender();
-              break;
-            case "down":
-            case "j":
-              select.moveDown();
-              renderer.requestRender();
-              break;
-            case "return":
-            case "enter":
-              finish({ action: "commit", index: select.getSelectedIndex() });
-              break;
-            case "e":
-              finish({ action: "edit", index: select.getSelectedIndex() });
-              break;
-            case "q":
-            case "escape":
-              finish({ action: "cancel" });
-              break;
-            case "c":
-              if (key.ctrl) finish({ action: "cancel" });
-              break;
-          }
-        } catch {
-          // A renderable method threw unexpectedly. Rather than let the error
-          // escape the key handler and leave the terminal stuck in raw mode,
-          // cancel cleanly - finish() restores the terminal via cleanup().
-          finish({ action: "cancel" });
-        }
-      };
-
-      renderer.keyInput.on("keypress", onKey);
-      renderer.start();
-      renderer.requestRender();
-    } catch (err) {
-      cleanup();
-      reject(err);
-    }
-  });
-}
-
-/** Plain-prompt fallback when the TUI is unavailable. */
-async function selectWithReadline(messages: string[]): Promise<Selection> {
-  process.stderr.write("\nCandidate commit messages:\n");
-  messages.forEach((m, i) =>
-    process.stderr.write(`  ${i + 1}. ${firstLine(m)}\n`),
-  );
-
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
-  try {
-    for (;;) {
-      const answer = (
-        await new Promise<string>((res) =>
-          rl.question(
-            `Choose 1-${messages.length}, "e N" to edit, or q to quit: `,
-            res,
-          ),
-        )
-      )
-        .trim()
-        .toLowerCase();
-
-      if (answer === "q" || answer === "") return { action: "cancel" };
-
-      const editMatch = answer.match(/^e\s*(\d+)$/);
-      if (editMatch) {
-        const index = parseInt(editMatch[1]!, 10) - 1;
-        if (index >= 0 && index < messages.length)
-          return { action: "edit", index };
-      }
-
-      const choice = parseInt(answer, 10);
-      if (choice >= 1 && choice <= messages.length) {
-        return { action: "commit", index: choice - 1 };
-      }
-      process.stderr.write("Invalid choice.\n");
-    }
-  } finally {
-    rl.close();
-  }
-}
-
-function firstLine(text: string): string {
-  return text.split("\n", 1)[0] ?? text;
-}
-
-/** A short, single-line preview of a message body (everything after the subject). */
-function bodyPreview(text: string): string {
-  const rest = text.split("\n").slice(1).join(" ").replace(/\s+/g, " ").trim();
-  return rest.length > 120 ? rest.slice(0, 117) + "…" : rest;
-}