@synmux/claude-commit 1.0.3 → 1.1.0

package/src/generate.ts

@@ -1,478 +0,0 @@
-/**
- * The commit-message pipeline:
- *
- *   diff ──ignore──▶ ──partition──▶ primary diff, low-priority diff
- *        ──split──▶ [chunk, chunk, ...] ──summary model──▶ [summary, ...]
- *        ──final model──▶ commit message(s)
- *
- * The `ignore` patterns run first and remove file sections outright, so
- * ignored content is never chunked, never sent and never paid for. Those
- * files are still committed - `ignore` governs what the model reads, not
- * what git stages - but when it matches *everything* there is nothing left
- * to describe and the run stops rather than inventing a message.
- *
- * The remaining diff is partitioned by the configured `lowPriorityPaths`: file
- * sections under those paths (generated docs, lockfiles, ...) form a
- * low-priority partition that is summarised after, and more briefly than,
- * the primary one, and the final model is told which is which so the
- * subject line describes the primary changes. When every file is low
- * priority the partition is promoted and the run is identical to one with
- * no patterns configured.
- *
- * The summary model (default `sonnet`) reads each diff chunk and writes a
- * factual summary; chunks are sized by a content-classified token estimate
- * (`splitDiffToFit`) so each request fits the model's context window, and a
- * chunk the backend still rejects as too long is re-split with a halved
- * budget and retried - the rejection happens before the model runs and is
- * not billed, so the API acts as the final arbiter of token counts. The
- * final model (default `sonnet`) turns the summaries into the commit
- * message(s), applying the configured formatting rules.
- */
-import { runPrompt } from "./agent";
-import { isOllamaModel } from "./models";
-import { resolveOllamaContext } from "./ollama";
-import {
-  applyIgnorePatterns,
-  partitionDiff,
-  redactOpaqueRuns,
-  splitDiffToFit,
-} from "./diff";
-import { createPathMatcher } from "./paths";
-import { clampChunkTokens } from "./tokens";
-import { ClaudeCommitError, isPromptTooLongError } from "./errors";
-import {
-  buildFinalSystem,
-  buildFinalUser,
-  buildSummarySystem,
-  buildSummaryUser,
-  cleanMessage,
-  extractMessages,
-  hasLowPrioritySummaries,
-  MESSAGES_SCHEMA,
-  parseOptions,
-} from "./prompts";
-import type {
-  ChangePriority,
-  Config,
-  DiffSummary,
-  OllamaConfig,
-} from "./types";
-
-export interface GenerateProgress {
-  /** Called when a new phase of work begins (for spinner labels). */
-  onPhase?: (label: string) => void;
-  /** Receives streamed text of the final message as it is produced. */
-  onText?: (delta: string) => void;
-}
-
-export interface GenerateOptions {
-  /** Number of candidate messages to produce (interactive mode uses > 1). */
-  count?: number;
-  progress?: GenerateProgress;
-  abortController?: AbortController;
-  /**
-   * Model runner used for every prompt; injectable so tests can exercise the
-   * pipeline (including overflow retries) without real model calls.
-   * Defaults to {@link runPrompt}.
-   */
-  runner?: typeof runPrompt;
-  /**
-   * Resolves an `ollama:` model's context window, called once per model
-   * per run before any chunk is sized; injectable so tests can exercise an
-   * `"auto"` configuration without a server. Defaults to
-   * {@link resolveOllamaContext}.
-   */
-  resolveOllamaContext?: typeof resolveOllamaContext;
-}
-
-/** The context window one Ollama model ran with during this run. */
-export interface OllamaContextWindow {
-  /** The model string as configured, prefix included. */
-  model: string;
-  tokens: number;
-  /** Whether the number was configured or chosen by the server (`"auto"`). */
-  source: "config" | "auto";
-}
-
-/** How the `ignore` patterns applied to this diff (for `--verbose`). */
-export interface IgnoreStats {
-  /** File sections dropped before any model saw them. */
-  ignoredFiles: number;
-  /** File sections in the staged diff with a recognisable path. */
-  totalFiles: number;
-}
-
-/** How the `lowPriorityPaths` patterns applied to this diff (for `--verbose`). */
-export interface LowPriorityStats {
-  /** File sections whose paths all matched a pattern. */
-  matchedFiles: number;
-  /** File sections in the diff with a recognisable path. */
-  totalFiles: number;
-  /** Every file matched, so the changes were treated as primary after all. */
-  promoted: boolean;
-}
-
-export interface GenerateResult {
-  /** Candidate commit messages (length 1 in non-interactive mode). */
-  messages: string[];
-  /** The intermediate summaries, primary first, each tagged with its priority. */
-  summaries: DiffSummary[];
-  /** Number of diff chunks the summary stage processed, across both partitions. */
-  chunkCount: number;
-  /** Total cost across all model calls, in USD. */
-  costUsd: number;
-  /** How the low-priority patterns applied to this diff. */
-  lowPriority: LowPriorityStats;
-  /** How the ignore patterns applied to this diff. */
-  ignored: IgnoreStats;
-  /** The context window each Ollama model ran with, in order of first use. */
-  ollamaContexts: OllamaContextWindow[];
-}
-
-/**
- * Resolves each `ollama:` model's context window once and hands back an
- * {@link OllamaConfig} with the number pinned in place of `"auto"`, so the
- * runner never repeats the probe. Claude models get `undefined`: they
- * neither need nor understand the block.
- */
-class OllamaContextResolver {
-  private readonly windows = new Map<string, Promise<number>>();
-  readonly resolved: OllamaContextWindow[] = [];
-
-  constructor(
-    private readonly config: OllamaConfig,
-    private readonly resolve: typeof resolveOllamaContext,
-    private readonly signal?: AbortSignal,
-  ) {}
-
-  /** The Ollama settings to run `model` with, or `undefined` for a Claude model. */
-  async settingsFor(model: string): Promise<OllamaConfig | undefined> {
-    if (!isOllamaModel(model)) return undefined;
-    const tokens = await this.windowFor(model);
-    return { ...this.config, context: tokens };
-  }
-
-  private windowFor(model: string): Promise<number> {
-    let pending = this.windows.get(model);
-    if (!pending) {
-      pending = this.resolve(model, this.config, this.signal).then((tokens) => {
-        this.resolved.push({
-          model,
-          tokens,
-          source: this.config.context === "auto" ? "auto" : "config",
-        });
-        return tokens;
-      });
-      this.windows.set(model, pending);
-    }
-    return pending;
-  }
-}
-
-/**
- * Floor for overflow-retry halving. Below this a chunk is essentially
- * prompt-sized already, so a "prompt is too long" rejection indicates
- * something other than chunk sizing and is surfaced instead of retried.
- */
-const MIN_RETRY_CHUNK_TOKENS = 8_000;
-
-interface PartitionSummaryOptions {
-  config: Config;
-  runner: typeof runPrompt;
-  progress: GenerateProgress;
-  contexts: OllamaContextResolver;
-  abortController?: AbortController;
-}
-
-/** Spinner label for one chunk of a partition. */
-function readingLabel(
-  priority: ChangePriority,
-  position: number,
-  total: number,
-): string {
-  const subject = priority === "low" ? "low-priority diff" : "diff";
-  return total > 1
-    ? `Reading ${subject} (part ${position + 1}/${total})`
-    : `Reading ${subject}`;
-}
-
-/**
- * Stage 1 for one partition: split it into chunks and summarise each, via a
- * work queue so an oversized chunk can be re-split and retried in place.
- * The estimate is calibrated, but only the backend knows the true token
- * count; its "prompt is too long" rejection is free, so treat it as the
- * final arbiter: halve the budget, re-split just that chunk, and continue
- * where we left off. Returns no summaries for an empty partition.
- */
-async function summarizePartition(
-  diff: string,
-  priority: ChangePriority,
-  options: PartitionSummaryOptions,
-): Promise<{ summaries: DiffSummary[]; costUsd: number }> {
-  const { config, runner, progress, contexts, abortController } = options;
-
-  // The configured chunk budget is clamped to the summary model's context
-  // window so a single chunk (plus prompt scaffolding and response headroom)
-  // can never overflow it, whatever `maxChunkTokens` says. For an Ollama
-  // model that window is resolved here first - possibly by asking the
-  // server - so the chunks and the request agree on the same number.
-  // Chunks are sized by a content-classified token estimate: opaque content
-  // (age/gpg armor, binary patches) measures near 1 char/token, so a plain
-  // chars-based budget underestimates armor-heavy diffs more than threefold.
-  const ollama = await contexts.settingsFor(config.models.summary);
-  const chunkTokens = clampChunkTokens(
-    config.models.summary,
-    config.maxChunkTokens,
-    typeof ollama?.context === "number" ? ollama.context : undefined,
-  );
-  const chunks = splitDiffToFit(diff, chunkTokens, config.charsPerToken);
-
-  const summarySystem = buildSummarySystem(priority);
-  const summaries: DiffSummary[] = [];
-  let costUsd = 0;
-
-  const queue = chunks.map((chunk) => ({ chunk, tokenBudget: chunkTokens }));
-  while (queue.length > 0) {
-    const task = queue.shift()!;
-    const position = summaries.length;
-    const total = summaries.length + queue.length + 1;
-    progress.onPhase?.(readingLabel(priority, position, total));
-    try {
-      const result = await runner(
-        buildSummaryUser(task.chunk, position, total, priority),
-        {
-          model: config.models.summary,
-          system: summarySystem,
-          allowApiKey: config.allowApiKey,
-          ...(ollama ? { ollama } : {}),
-          ...(abortController ? { abortController } : {}),
-        },
-      );
-      summaries.push({ priority, text: result.text });
-      costUsd += result.costUsd;
-    } catch (error) {
-      const halvedBudget = Math.floor(task.tokenBudget / 2);
-      if (
-        !isPromptTooLongError(error) ||
-        halvedBudget < MIN_RETRY_CHUNK_TOKENS
-      ) {
-        throw error;
-      }
-      const pieces = splitDiffToFit(
-        task.chunk,
-        halvedBudget,
-        config.charsPerToken,
-      );
-      if (pieces.length === 1 && pieces[0] === task.chunk) {
-        // Nothing left to split on (a single oversized hunk): retrying the
-        // identical request would loop forever, so surface the error.
-        throw error;
-      }
-      queue.unshift(
-        ...pieces.map((chunk) => ({ chunk, tokenBudget: halvedBudget })),
-      );
-    }
-  }
-
-  return { summaries, costUsd };
-}
-
-/** Run the full pipeline over a staged diff. */
-export async function generateCommit(
-  diff: string,
-  config: Config,
-  options: GenerateOptions = {},
-): Promise<GenerateResult> {
-  const {
-    count = 1,
-    progress = {},
-    abortController,
-    runner = runPrompt,
-    resolveOllamaContext: resolveContext = resolveOllamaContext,
-  } = options;
-  const contexts = new OllamaContextResolver(
-    config.ollama,
-    resolveContext,
-    abortController?.signal,
-  );
-
-  // Ignore first: dropped sections cost nothing downstream. Unlike a
-  // low-priority partition, an ignored one has nowhere to be promoted to,
-  // so matching every file is a dead end rather than a special case.
-  const ignoreResult = applyIgnorePatterns(
-    diff,
-    createPathMatcher(config.ignore),
-  );
-  const ignored: IgnoreStats = {
-    ignoredFiles: ignoreResult.ignoredFiles,
-    totalFiles: ignoreResult.totalFiles,
-  };
-  if (ignoreResult.diff.trim() === "" && ignoreResult.ignoredFiles > 0) {
-    throw new ClaudeCommitError(describeFullyIgnored(ignored));
-  }
-
-  const effectiveDiff = config.skipArmored
-    ? redactOpaqueRuns(ignoreResult.diff)
-    : ignoreResult.diff;
-  const partition = partitionDiff(
-    effectiveDiff,
-    createPathMatcher(config.lowPriorityPaths),
-  );
-  if (partition.primary.trim() === "") {
-    throw new ClaudeCommitError("There are no staged changes to summarize.");
-  }
-
-  // Stage 1: summarise the primary partition first - fail fast on the part
-  // that matters - then the low-priority one (skipped when empty).
-  const partitionOptions: PartitionSummaryOptions = {
-    config,
-    runner,
-    progress,
-    contexts,
-    ...(abortController ? { abortController } : {}),
-  };
-  const primaryStage = await summarizePartition(
-    partition.primary,
-    "primary",
-    partitionOptions,
-  );
-  const lowPriorityStage =
-    partition.lowPriority.trim() === ""
-      ? { summaries: [], costUsd: 0 }
-      : await summarizePartition(
-          partition.lowPriority,
-          "low",
-          partitionOptions,
-        );
-  const summaries = [...primaryStage.summaries, ...lowPriorityStage.summaries];
-  if (summaries.length === 0) {
-    throw new ClaudeCommitError("There are no staged changes to summarize.");
-  }
-  let costUsd = primaryStage.costUsd + lowPriorityStage.costUsd;
-  const hasLowPriority = hasLowPrioritySummaries(summaries);
-
-  // Stage 2: write the commit message(s) from the summaries.
-  //
-  // Prefer a structured (JSON-schema) response so parsing is robust regardless
-  // of how the model formats its prose. We try, in order: structured output
-  // with a temperature bump (for interactive variety), then structured output
-  // without it (for models that reject a temperature override), then plain text
-  // with delimiter parsing (for models that don't support structured output at
-  // all). Whichever succeeds first wins.
-  progress.onPhase?.(
-    count > 1 ? "Writing commit options" : "Writing commit message",
-  );
-
-  const finalOllama = await contexts.settingsFor(config.models.final);
-  const baseOpts = {
-    model: config.models.final,
-    allowApiKey: config.allowApiKey,
-    ...(finalOllama ? { ollama: finalOllama } : {}),
-    ...(abortController ? { abortController } : {}),
-  };
-  const temperature =
-    count > 1 && config.interactiveTemperature != null
-      ? config.interactiveTemperature
-      : undefined;
-
-  const attempts: Array<{ structured: boolean; temperature?: number }> = [];
-  if (temperature != null) attempts.push({ structured: true, temperature });
-  attempts.push({ structured: true });
-  attempts.push({ structured: false });
-
-  let messages: string[] | null = null;
-  let lastError: unknown;
-  for (const attempt of attempts) {
-    try {
-      const result = await runner(
-        buildFinalUser(summaries, count, attempt.structured),
-        {
-          ...baseOpts,
-          system: buildFinalSystem(config, attempt.structured, hasLowPriority),
-          ...(attempt.structured
-            ? {
-                outputFormat: {
-                  type: "json_schema" as const,
-                  schema: MESSAGES_SCHEMA,
-                },
-              }
-            : {}),
-          ...(attempt.temperature != null
-            ? { temperature: attempt.temperature }
-            : {}),
-          ...(!attempt.structured && progress.onText
-            ? { onText: progress.onText }
-            : {}),
-        },
-      );
-      costUsd += result.costUsd;
-      messages = attempt.structured
-        ? extractMessages(result.structured)
-        : count > 1
-          ? parseOptions(result.text)
-          : [result.text];
-      if (messages && messages.length > 0) break;
-    } catch (err) {
-      lastError = err;
-      // If the run was cancelled, stop retrying: the shared abort signal would
-      // make every remaining attempt fail immediately in the same way.
-      if (abortController?.signal.aborted) break;
-    }
-  }
-
-  const cleaned = (messages ?? [])
-    .map(cleanMessage)
-    .filter((message) => message.length > 0);
-  const deduped = dedupe(cleaned);
-  if (deduped.length === 0) {
-    if (lastError instanceof ClaudeCommitError) throw lastError;
-    throw new ClaudeCommitError("The model did not produce a commit message.");
-  }
-
-  // Report chunks actually processed: overflow retries can split further
-  // than the initial estimate planned.
-  return {
-    messages: deduped,
-    summaries,
-    chunkCount: summaries.length,
-    costUsd,
-    lowPriority: {
-      matchedFiles: partition.matchedFiles,
-      totalFiles: partition.totalFiles,
-      promoted: partition.promoted,
-    },
-    ignored,
-    ollamaContexts: contexts.resolved,
-  };
-}
-
-/**
- * The error for a commit whose every changed file matched `ignore`.
- *
- * There is no sensible fallback here. Describing the ignored files anyway
- * would contradict the directive the user wrote; committing an empty or
- * invented message would be worse. Naming the directive and the count makes
- * the cause obvious, because the alternative - a run that mysteriously
- * reports no staged changes when `git status` plainly disagrees - is the
- * kind of bug people spend an afternoon on.
- */
-export function describeFullyIgnored(stats: IgnoreStats): string {
-  const files = `${stats.ignoredFiles} staged file${stats.ignoredFiles === 1 ? "" : "s"}`;
-  return (
-    `Every one of the ${files} matches an "ignore" pattern, so there is ` +
-    `nothing left to describe. Narrow the patterns, or pass --no-ignore to ` +
-    `write a message about these changes for this commit.`
-  );
-}
-
-function dedupe(items: string[]): string[] {
-  const seen = new Set<string>();
-  const out: string[] = [];
-  for (const item of items) {
-    if (!seen.has(item)) {
-      seen.add(item);
-      out.push(item);
-    }
-  }
-  return out;
-}

package/src/git.ts

@@ -1,145 +0,0 @@
-/**
- * Git operations, implemented with Bun's shell (`Bun.$`).
- */
-import { $ } from "bun";
-import { ClaudeCommitError } from "./errors";
-import type { FileChange } from "./types";
-
-/**
- * A git command failed. Subclasses {@link ClaudeCommitError} so the CLI prints
- * it as a clean, user-facing error rather than a stack trace.
- */
-export class GitError extends ClaudeCommitError {
-  override name = "GitError";
-}
-
-/** Run a git command, returning stdout. Throws {@link GitError} on failure. */
-async function git(args: string[]): Promise<string> {
-  let res;
-  try {
-    res = await $`git ${args}`.quiet().nothrow();
-  } catch (err) {
-    // Should not happen with `.nothrow()`, but never let a raw shell error leak.
-    throw new GitError(`Could not run git: ${(err as Error).message}`);
-  }
-  if (res.exitCode !== 0) {
-    const stderr = res.stderr.toString().trim();
-    throw new GitError(
-      stderr || `git ${args.join(" ")} exited with code ${res.exitCode}`,
-    );
-  }
-  return res.stdout.toString();
-}
-
-/** True if the current working directory is inside a git work tree. */
-export async function isGitRepo(): Promise<boolean> {
-  try {
-    const res = await $`git rev-parse --is-inside-work-tree`.quiet().nothrow();
-    return res.exitCode === 0 && res.stdout.toString().trim() === "true";
-  } catch {
-    // git missing or unrunnable - treat as "not a usable repo".
-    return false;
-  }
-}
-
-/** Absolute path to the repository root. */
-export async function getRepoRoot(): Promise<string> {
-  return (await git(["rev-parse", "--show-toplevel"])).trim();
-}
-
-/**
- * Flags that pin the shape and membership of every staged-change reader
- * against user diff settings. The list is exhaustive, not illustrative:
- *
- * - `--no-relative`: with `diff.relative=true`, running from a subdirectory
- *   would both strip leading path segments (breaking `lowPriorityPaths`
- *   matching, which is always repository-root-relative) and omit staged
- *   files outside that directory entirely, so the message would describe a
- *   subset of what gets committed.
- * - `--no-ext-diff`: `diff.external` / `GIT_EXTERNAL_DIFF` / a gitattributes
- *   `diff=<driver>` replace the diff body wholesale - a difftastic-style
- *   driver emits no `diff --git` headers at all, and a driver can even forge
- *   headers that attach one file's changes to another path.
- * - `--ignore-submodules=none`: `diff.ignoreSubmodules=all` erases a staged
- *   submodule bump from all three readers.
- * - `--submodule=short`: `diff.submodule=log|diff` replace a submodule's
- *   `diff --git` section with a header-less `Submodule <path> <a>..<b>:`
- *   block, which the section splitter would glue onto the preceding file's
- *   section (and priority).
- * - The `a/`/`b/` prefixes are forced so `diff.noprefix` /
- *   `diff.mnemonicPrefix` cannot change the header format the diff parser
- *   (`sectionPaths` in `src/diff.ts`) expects.
- */
-const STAGED_DIFF_FLAGS = [
-  "--cached",
-  "--no-color",
-  "--no-relative",
-  "--no-ext-diff",
-  "--ignore-submodules=none",
-  "--submodule=short",
-  "--src-prefix=a/",
-  "--dst-prefix=b/",
-];
-
-/** The unified diff of staged changes (`git diff --cached`), repository-root-relative. */
-export async function getStagedDiff(): Promise<string> {
-  return git(["diff", ...STAGED_DIFF_FLAGS]);
-}
-
-/** Parsed list of staged files with their status codes. */
-export async function getStagedFiles(): Promise<FileChange[]> {
-  const out = await git(["diff", ...STAGED_DIFF_FLAGS, "--name-status"]);
-  return out
-    .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => {
-      const parts = line.split("\t");
-      const status = parts[0] ?? "";
-      // For renames/copies (`R100\told\tnew`) the destination is the last field.
-      const path = parts[parts.length - 1] ?? "";
-      return { status, path };
-    });
-}
-
-/** Stage every change in the work tree (`git add -A`). */
-export async function stageAll(): Promise<void> {
-  await git(["add", "-A"]);
-}
-
-/** A short one-line stat summary of staged changes (for display). */
-export async function getStagedStat(): Promise<string> {
-  return (await git(["diff", ...STAGED_DIFF_FLAGS, "--stat"])).trimEnd();
-}
-
-/**
- * Create a commit with the given message. The message is piped to
- * `git commit -F -` over stdin, so arbitrary content (leading dashes, multiple
- * lines, special characters) is handled safely - and nothing touches disk, so
- * there is no temp file to be raced or read by another user.
- */
-export async function commit(message: string): Promise<void> {
-  let proc;
-  try {
-    // `Bun.spawn` throws synchronously if `git` isn't on PATH.
-    proc = Bun.spawn(["git", "commit", "-F", "-"], {
-      stdin: new TextEncoder().encode(message),
-      // We surface our own confirmation, so discard git's stdout summary rather
-      // than leaving an unread pipe that could (in theory) fill and block.
-      stdout: "ignore",
-      stderr: "pipe",
-    });
-  } catch (err) {
-    throw new GitError(`Could not run git: ${(err as Error).message}`);
-  }
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = (await new Response(proc.stderr).text()).trim();
-    throw new GitError(stderr || `git commit exited with code ${exitCode}`);
-  }
-}
-
-/** The current branch name (or `HEAD` when detached). */
-export async function getCurrentBranch(): Promise<string> {
-  return (await git(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
-}