@synmux/claude-commit 1.0.3 → 1.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Library entry point for `claude-commit`.
+ *
+ * Re-exports the building blocks so the commit-message pipeline can be used
+ * programmatically. The CLI lives in `bin/cco.ts` (`src/cli.ts`).
+ */
+export { generateCommit } from "./src/generate.ts";
+export type { GenerateOptions, GenerateProgress, GenerateResult, IgnoreStats, LowPriorityStats, OllamaContextWindow, } from "./src/generate.ts";
+export { runClaudePrompt, runPrompt } from "./src/agent.ts";
+export type { RunPromptOptions } from "./src/agent.ts";
+export { probeOllamaContext, resolveOllamaContext, resolveOllamaHost, runOllamaPrompt, } from "./src/ollama.ts";
+export { DEFAULT_OLLAMA_CONTEXT, DEFAULT_OLLAMA_CONTEXT_TOKENS, DEFAULT_OLLAMA_HOST, isOllamaModel, OLLAMA_PREFIX, parseModelRef, } from "./src/models.ts";
+export type { ModelProvider, ModelRef } from "./src/models.ts";
+export { applyIgnorePatterns, diffPaths, partitionDiff, sectionPaths, splitDiff, } from "./src/diff.ts";
+export type { DiffPartition, IgnoreResult } from "./src/diff.ts";
+export { createPathMatcher, matchesPathPatterns } from "./src/paths.ts";
+export type { PathMatcher } from "./src/paths.ts";
+export { DEFAULT_CONFIG, loadFileConfig, resolveConfig, mergeConfig, mergePartial, sanitizePartial, } from "./src/config.ts";
+export { buildSummarySystem, buildSummaryUser, buildFinalSystem, buildFinalUser, buildFilenamesUser, parseOptions, cleanMessage, } from "./src/prompts.ts";
+export * as git from "./src/git.ts";
+export { ClaudeCommitError } from "./src/errors.ts";
+export type { ChangePriority, Config, DiffSummary, ModelConfig, OllamaConfig, PartialConfig, ModelResult, FileChange, } from "./src/types.ts";

package/dist/types/src/agent.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The model-call layer: {@link runPrompt} turns one prompt into one text
+ * completion, routing to whichever backend the model name asks for.
+ *
+ * A bare model name goes to Claude, through the Agent SDK, below. An
+ * `ollama:`-prefixed one goes to `src/ollama.ts` instead. Both return the
+ * same {@link ModelResult}, so the pipeline in `src/generate.ts` - and the
+ * injectable runner its tests use - never learns which provider ran.
+ *
+ * The Claude path, in detail:
+ *
+ * The Agent SDK spawns a bundled `claude` binary, so authentication follows
+ * Claude Code's own resolution order over the environment we hand it. By
+ * default the API credential variables (`ANTHROPIC_API_KEY` /
+ * `ANTHROPIC_AUTH_TOKEN`) are stripped from that environment, forcing the
+ * `claude login` subscription session so the cost is bundled with Claude Code
+ * usage; the `allowApiKey` config option passes them through for explicit
+ * pay-as-you-go billing. Every request runs fully isolated from the user's
+ * Claude Code configuration - no tools, skills, MCP servers, plugins, or
+ * settings (see {@link buildQueryOptions}) - so the request contains nothing
+ * beyond the prompt we build.
+ */
+import { type Options } from "@anthropic-ai/claude-agent-sdk";
+import type { ModelResult, RunPromptOptions } from "./types.ts";
+export type { RunPromptOptions } from "./types.ts";
+export declare const GATED_CREDENTIAL_VARS: readonly ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
+/**
+ * Names of the gated credential variables present in `env`. An empty string
+ * counts as present, since presence alone perturbs credential resolution.
+ */
+export declare function presentCredentialVars(env: Record<string, string | undefined>): string[];
+export interface SubprocessEnvOptions {
+    /** Environment to derive the subprocess environment from (usually `process.env`). */
+    baseEnv: Record<string, string | undefined>;
+    /**
+     * Pass API credential variables through instead of stripping them.
+     * Defaults to false so the gate fails safe when a caller omits it.
+     */
+    allowApiKey?: boolean;
+    /** Sampling temperature to inject via `CLAUDE_CODE_EXTRA_BODY`, preserving any existing extra body. */
+    temperature?: number;
+}
+/**
+ * Build the environment for the Claude Agent SDK subprocess, or return
+ * `undefined` when the parent environment can be inherited unchanged.
+ *
+ * Unless `allowApiKey` is set, API credential variables are removed so the
+ * spawned `claude` binary always authenticates with the user's subscription
+ * session - an exported `ANTHROPIC_API_KEY` must never silently switch
+ * billing to pay-as-you-go.
+ */
+export declare function buildSubprocessEnv(opts: SubprocessEnvOptions): Record<string, string | undefined> | undefined;
+/**
+ * Build the Agent SDK options for one isolated, single-turn text completion.
+ *
+ * Isolation is layered because the SDK gates each context source separately:
+ *
+ * - `settingSources: []` disables settings files and `CLAUDE.md` - and only
+ *   those. It does NOT stop MCP servers or skills from loading.
+ * - `mcpServers: {}` + `strictMcpConfig: true` ignore every MCP server
+ *   configured in `~/.claude.json`, project `.mcp.json`, and plugins.
+ * - `skills: []` disables skill discovery, which the CLI otherwise performs
+ *   even when the `skills` option is omitted entirely.
+ * - `tools: []` and `plugins: []` drop all built-in tools and plugins.
+ *
+ * Omitting any of these lets the user's global Claude Code configuration
+ * (MCP tool schemas, skill listings - easily hundreds of thousands of tokens
+ * on a busy setup) into every request; with all of them set, live probes
+ * measure ~170 input tokens per request. Historical note: the 2026-07
+ * "Prompt is too long" failures were ultimately caused by underestimating
+ * the token density of armored diff content (see `estimateDiffTokens`), not
+ * by this leak - the isolation is hygiene and cost control, not the fix for
+ * that bug.
+ */
+export declare function buildQueryOptions(opts: RunPromptOptions, subprocessEnv?: Record<string, string | undefined>): Options;
+/**
+ * Run a single prompt against a Claude model via the Agent SDK.
+ *
+ * Throws {@link ClaudeCommitError} on any model/authentication/quota failure.
+ */
+export declare function runClaudePrompt(prompt: string, opts: RunPromptOptions): Promise<ModelResult>;
+/**
+ * Run a single prompt against whichever provider `opts.model` names, and
+ * return its text response.
+ *
+ * This is the single seam every caller uses; `generate.ts` accepts a
+ * replacement of exactly this shape so the pipeline can be tested without a
+ * model of either kind.
+ *
+ * Throws {@link ClaudeCommitError} on any model, authentication, transport
+ * or quota failure.
+ */
+export declare function runPrompt(prompt: string, opts: RunPromptOptions): Promise<ModelResult>;

package/dist/types/src/config.d.ts

@@ -0,0 +1,36 @@
+import type { Config, PartialConfig } from "./types.ts";
+export declare const DEFAULT_CONFIG: Config;
+/**
+ * The user-level config directory, `$XDG_CONFIG_HOME/claude-commit` (falling back
+ * to `~/.config/claude-commit`). Per the XDG Base Directory spec, `XDG_CONFIG_HOME`
+ * is honoured only when it is set to an absolute path.
+ */
+export declare function globalConfigDir(env?: Record<string, string | undefined>): string;
+/**
+ * Deep-ish merge of a partial config over a base config: `models` and
+ * `ollama` are merged key by key; the path lists (`lowPriorityPaths`,
+ * `ignore`) are replaced whole - a higher layer's list wins outright, so a
+ * project can drop a global pattern - and copied so the result never
+ * aliases the base's array.
+ */
+export declare function mergeConfig(base: Config, override: PartialConfig): Config;
+/** Validate and normalize a parsed partial config, ignoring unknown keys. */
+export declare function sanitizePartial(raw: unknown): PartialConfig;
+/**
+ * Load and merge the file-based configuration layers that sit below CLI flags,
+ * lowest first: the global user config, then `package.json`'s `claude-commit` key
+ * at the repo root, then the nearest project config file (searched from `cwd` up
+ * to `repoRoot`). An explicit `configPath` short-circuits the project-file
+ * discovery; the global and `package.json` layers still apply beneath it. `env`
+ * supplies `XDG_CONFIG_HOME` for locating the global config (defaults to
+ * `process.env`).
+ */
+export declare function loadFileConfig(cwd: string, repoRoot: string, configPath?: string, env?: Record<string, string | undefined>): Promise<PartialConfig>;
+/**
+ * Merge two partial configs: `models` and `ollama` are merged key by key;
+ * every other key, including both path lists, is taken whole from the
+ * override when present.
+ */
+export declare function mergePartial(base: PartialConfig, override: PartialConfig): PartialConfig;
+/** Produce a fully-resolved config from file config and CLI-flag overrides. */
+export declare function resolveConfig(fileConfig: PartialConfig, flagConfig: PartialConfig): Config;

package/dist/types/src/diff.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Splitting a unified git diff into chunks that fit a character budget, and
+ * partitioning it by path priority.
+ *
+ * The packer is structure-aware: it prefers to break on file boundaries, then
+ * on hunk (`@@`) boundaries, and only falls back to raw line splitting for a
+ * single hunk that is itself larger than the budget. When a file section is
+ * split, its header (`diff --git ... / --- / +++`) is repeated at the top of
+ * every piece so each chunk remains a self-contained, interpretable diff.
+ *
+ * `applyIgnorePatterns` drops whole file sections outright (see `ignore` in
+ * the config) and `partitionDiff` sorts what remains into a primary and a
+ * low-priority diff (see `lowPriorityPaths`), both using the paths
+ * `sectionPaths` recovers from each section's header lines.
+ */
+import type { PathMatcher } from "./paths.ts";
+/**
+ * Split a unified diff into chunks no larger than `maxChars` characters.
+ *
+ * Returns an empty array for an empty diff, and a single-element array when the
+ * whole diff already fits.
+ */
+export declare function splitDiff(diff: string, maxChars: number): string[];
+/**
+ * Replace each run of opaque (armored/encoded) lines with a single marker
+ * line. The marker keeps the surrounding diff structure interpretable and
+ * tells the summary model what was elided, so it can still report that an
+ * encrypted file changed - without paying ~1 token per character to send
+ * ciphertext the model cannot read anyway.
+ */
+export declare function redactOpaqueRuns(diff: string): string;
+/**
+ * The staged diff split by path priority. `primary` drives the commit
+ * message; `lowPriority` holds the sections whose every path matched a
+ * `lowPriorityPaths` pattern. Either may be `""`. The counts make the
+ * matcher observable (`--verbose`): a pattern that matches nothing and one
+ * that matches everything (and is therefore promoted) produce the same
+ * message otherwise.
+ */
+export interface DiffPartition {
+    primary: string;
+    lowPriority: string;
+    /** File sections whose paths all matched. */
+    matchedFiles: number;
+    /** File sections with at least one recognisable path. */
+    totalFiles: number;
+    /** Every file matched, so the low-priority sections were promoted to primary. */
+    promoted: boolean;
+}
+/**
+ * The repository-relative paths a file section touches: one for an ordinary
+ * change, two for a rename or copy. Paths are read from the `---`/`+++`
+ * marker lines and `rename`/`copy from`/`to` lines in the section header
+ * (before the first hunk, so a removed line that happens to start with
+ * `-- ` is never mistaken for a marker), falling back to the
+ * `diff --git a/X b/Y` line for sections that have none. Returns `[]` for
+ * content that is not a file section at all.
+ */
+export declare function sectionPaths(section: string): string[];
+/**
+ * Unique repository-relative filenames touched by a diff, in encounter
+ * order. Includes both paths of renames and copies. Uses the same header
+ * parser as ignore/priority matching, so hunk contents cannot become names.
+ */
+export declare function diffPaths(diff: string): string[];
+/**
+ * Sort a diff's file sections into a primary and a low-priority diff.
+ *
+ * A section is low priority only when it names at least one path and every
+ * path it names matches - so a rename into or out of a low-priority area
+ * stays primary, as does anything whose path cannot be recognised. Sections
+ * keep their original order within each partition and are joined back with
+ * newlines, so each partition is itself a valid unified diff.
+ *
+ * When nothing is primary, the low-priority sections are promoted: with no
+ * other change to yield to, they *are* the change and should be described
+ * in full, exactly as if no patterns were configured.
+ */
+export declare function partitionDiff(diff: string, isLowPriority: PathMatcher): DiffPartition;
+/** What `ignore` removed from a diff. */
+export interface IgnoreResult {
+    /** The diff with every ignored file section removed. May be `""`. */
+    diff: string;
+    /** File sections dropped because all of their paths matched. */
+    ignoredFiles: number;
+    /** File sections in the original diff with at least one recognisable path. */
+    totalFiles: number;
+}
+/**
+ * Drop the file sections whose every path matches, returning the rest.
+ *
+ * The rule is `partitionDiff`'s: a section is removed only when it names at
+ * least one path and all of them match, so a rename out of an ignored
+ * directory - which is news - survives, as does anything whose path cannot
+ * be read. Surviving sections keep their order and are joined with
+ * newlines, so the result is itself a valid unified diff.
+ *
+ * This runs before everything else in the pipeline, so ignored content is
+ * never chunked, never sent, and never paid for.
+ */
+export declare function applyIgnorePatterns(diff: string, isIgnored: PathMatcher): IgnoreResult;
+/**
+ * Split a diff so that every chunk's *classified token estimate* fits
+ * `maxTokens`.
+ *
+ * `splitDiff` budgets in characters, but token density varies wildly by
+ * content: prose and code sit near the configured `charsPerToken` (~3.5)
+ * while base64/armor lines measure near 1 char/token. Sizing every chunk
+ * with one blended ratio lets an armor-heavy region overflow, so after an
+ * initial blended-density split, any chunk still over budget is re-split
+ * using its own (denser) ratio until everything fits or no further split is
+ * possible. An unsplittable oversized chunk is kept - the overflow retry in
+ * the generation pipeline is the backstop for that case.
+ */
+export declare function splitDiffToFit(diff: string, maxTokens: number, charsPerToken: number): string[];

package/{src/errors.ts → dist/types/src/errors.d.ts}

@@ -1,8 +1,7 @@
 /** Error type for user-facing, expected failures (printed without a stack trace). */
-export class ClaudeCommitError extends Error {
-  override name = "ClaudeCommitError";
+export declare class ClaudeCommitError extends Error {
+    name: string;
 }
-
 /**
  * True when `error` is the backend rejecting a request for exceeding the
  * model's context window. Matched on message text because the Agent SDK
@@ -10,6 +9,4 @@ export class ClaudeCommitError extends Error {
  * re-split-and-retry: the rejection happens before the model runs, so it is
  * not billed.
  */
-export function isPromptTooLongError(error: unknown): boolean {
-  return error instanceof Error && /prompt is too long/i.test(error.message);
-}
+export declare function isPromptTooLongError(error: unknown): boolean;

package/dist/types/src/generate.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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.
+ * With filenamesOnly, the summary stage is skipped entirely and the final
+ * model receives only paths from the filtered, priority-grouped diff.
+ */
+import { runPrompt } from "./agent.ts";
+import { resolveOllamaContext } from "./ollama.ts";
+import type { Config, DiffSummary } from "./types.ts";
+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[];
+    /** Intermediate summaries, primary first. Empty when filenamesOnly is enabled. */
+    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[];
+}
+/** Run the full pipeline over a staged diff. */
+export declare function generateCommit(diff: string, config: Config, options?: GenerateOptions): Promise<GenerateResult>;
+/**
+ * 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 declare function describeFullyIgnored(stats: IgnoreStats): string;

package/dist/types/src/git.d.ts

@@ -0,0 +1,31 @@
+import { ClaudeCommitError } from "./errors.ts";
+import type { FileChange } from "./types.ts";
+/**
+ * A git command failed. Subclasses {@link ClaudeCommitError} so the CLI prints
+ * it as a clean, user-facing error rather than a stack trace.
+ */
+export declare class GitError extends ClaudeCommitError {
+    name: string;
+}
+/** True if the current working directory is inside a git work tree. */
+export declare function isGitRepo(): Promise<boolean>;
+/** Absolute path to the repository root. */
+export declare function getRepoRoot(): Promise<string>;
+/** The unified diff of staged changes (`git diff --cached`), repository-root-relative. */
+export declare function getStagedDiff(): Promise<string>;
+/** Parsed list of staged files with their status codes. */
+export declare function getStagedFiles(): Promise<FileChange[]>;
+/** Stage every change in the work tree (`git add -A`). */
+export declare function stageAll(): Promise<void>;
+/** A short one-line stat summary of staged changes (for display). */
+export declare function getStagedStat(): Promise<string>;
+/**
+ * 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. Git's own
+ * stdout summary is discarded: the CLI prints its own confirmation.
+ */
+export declare function commit(message: string): Promise<void>;
+/** The current branch name (or `HEAD` when detached). */
+export declare function getCurrentBranch(): Promise<string>;

package/dist/types/src/models.d.ts

@@ -0,0 +1,42 @@
+/** Marks a model name as belonging to an Ollama server. Case-insensitive. */
+export declare const OLLAMA_PREFIX = "ollama:";
+/** Which backend serves a model. */
+export type ModelProvider = "claude" | "ollama";
+/** A model string resolved into a provider and the name that provider expects. */
+export interface ModelRef {
+    provider: ModelProvider;
+    /** The model name to send to the provider, with any cco prefix removed. */
+    name: string;
+}
+/**
+ * Default Ollama base URL, used when neither the config nor `$OLLAMA_HOST`
+ * names one. This is Ollama's own default listen address.
+ */
+export declare const DEFAULT_OLLAMA_HOST = "http://localhost:11434";
+/**
+ * Default `ollama.context`: ask the server what window it would run the
+ * model with on this machine, rather than guess (see `probeOllamaContext`
+ * in `src/ollama.ts`). Ollama's choice is made from available VRAM and
+ * capped at the model's trained maximum, so it is the largest window the
+ * server believes it can actually load.
+ */
+export declare const DEFAULT_OLLAMA_CONTEXT: "auto";
+/**
+ * The window assumed for an `ollama:` model when nothing better is known:
+ * the synchronous fallback in `contextWindowTokens` for callers that size
+ * chunks without first resolving the context. The pipeline never relies on
+ * it - it resolves `"auto"` to a real number before sizing - so this only
+ * matters to direct library use. 32768 is Ollama's middle VRAM tier.
+ */
+export declare const DEFAULT_OLLAMA_CONTEXT_TOKENS = 32768;
+/** Whether `model` names an Ollama model (i.e. carries the `ollama:` prefix). */
+export declare function isOllamaModel(model: string): boolean;
+/**
+ * Resolve a configured model string into its provider and provider-side name.
+ *
+ * Throws {@link ClaudeCommitError} for a name that no provider could serve:
+ * an empty string, or an `ollama:` prefix with nothing after it.
+ */
+export declare function parseModelRef(model: string): ModelRef;
+/** A model string as it should appear in an error or a `--verbose` line. */
+export declare function describeModel(model: string): string;

package/dist/types/src/ollama.d.ts

@@ -0,0 +1,89 @@
+import type { ModelResult, OllamaConfig, RunPromptOptions } from "./types.ts";
+/** Ollama settings with every default filled in; the context may still be `"auto"`. */
+export interface ResolvedOllama {
+    host: string;
+    context: number | "auto";
+    keepAlive: string | number | null;
+}
+/** {@link ResolvedOllama} after `"auto"` has been turned into a number. */
+export interface OllamaRequestSettings {
+    host: string;
+    contextTokens: number;
+    keepAlive: string | number | null;
+}
+/**
+ * Normalise a base URL: add a scheme to a bare `host:port` and drop any
+ * trailing slash. Ollama's own `OLLAMA_HOST` convention allows the bare
+ * form, so `127.0.0.1:11434` has to mean what a user expects it to.
+ */
+export declare function normaliseOllamaHost(host: string): string;
+/**
+ * The Ollama base URL for this run: the configured `ollama.host`, else
+ * `$OLLAMA_HOST`, else {@link DEFAULT_OLLAMA_HOST}.
+ */
+export declare function resolveOllamaHost(configured?: string, env?: Record<string, string | undefined>): string;
+/**
+ * Fill in defaults for any Ollama setting the config left out. A missing
+ * or unusable `context` becomes `"auto"`; turning that into a number is
+ * {@link resolveOllamaContext}'s job, because it takes a round trip.
+ */
+export declare function resolveOllamaConfig(config: Partial<OllamaConfig> | undefined, env?: Record<string, string | undefined>): ResolvedOllama;
+/**
+ * Ask Ollama what context window it would run `model` with on this machine.
+ *
+ * Two calls. The first is a chat request with no messages, which loads the
+ * model (a no-op if it is already resident) *without* a `num_ctx` - so the
+ * server applies its own choice, made from available VRAM (4k / 32k / 256k
+ * tiers, capped at the model's trained maximum). The second reads that
+ * choice back from `/api/ps`, which reports the window each loaded model is
+ * actually running with. The load was going to happen on the first real
+ * request anyway, so the only added cost is the `ps` round trip.
+ *
+ * This is deliberately not `/api/show`'s `context_length`, which is the
+ * *trained* maximum regardless of hardware - 131072 for a model this
+ * machine may only be able to run at 32768. The number the server picked
+ * is the one it can actually load.
+ */
+export declare function probeOllamaContext(model: string, settings: {
+    host: string;
+    keepAlive: string | number | null;
+}, signal?: AbortSignal): Promise<number>;
+/**
+ * The context window to use for `model`: the configured number, or the
+ * server's own choice when the config says `"auto"` (see
+ * {@link probeOllamaContext}). Callers that make several requests to the
+ * same model should resolve once and reuse the result.
+ */
+export declare function resolveOllamaContext(model: string, config: Partial<OllamaConfig> | undefined, signal?: AbortSignal): Promise<number>;
+/** The body of a native `/api/chat` request. */
+export interface OllamaChatRequest {
+    model: string;
+    messages: Array<{
+        role: "system" | "user";
+        content: string;
+    }>;
+    stream: boolean;
+    format?: Record<string, unknown>;
+    keep_alive?: string | number;
+    options: Record<string, unknown>;
+}
+/**
+ * Build the `/api/chat` body for one prompt.
+ *
+ * Two things are deliberate. Sampling parameters go inside `options` - at the
+ * top level Ollama accepts and silently ignores them, so a misplaced
+ * `temperature` would look like a model that refuses to vary. And `think` is
+ * never sent at all: models disagree on whether reasoning can be switched
+ * off (gpt-oss cannot, and takes only a level; Granite uses its own field
+ * entirely), so asking is a needless way to earn a 400. Any `thinking` that
+ * comes back is dropped on the floor instead.
+ */
+export declare function buildChatRequest(prompt: string, opts: RunPromptOptions, settings: OllamaRequestSettings): OllamaChatRequest;
+/**
+ * Run a single prompt against an Ollama model and return its response.
+ *
+ * Throws {@link ClaudeCommitError} on any transport, model or truncation
+ * failure. `costUsd` is always zero: local inference is not billed, so a
+ * mixed-provider run's reported cost is exactly its Claude half.
+ */
+export declare function runOllamaPrompt(prompt: string, opts: RunPromptOptions): Promise<ModelResult>;

package/dist/types/src/paths.d.ts

@@ -0,0 +1,9 @@
+/** A predicate over repository-relative paths. */
+export type PathMatcher = (path: string) => boolean;
+/**
+ * Build a matcher for a list of gitignore-style patterns. Compile once per
+ * run and reuse it across every path in the diff.
+ */
+export declare function createPathMatcher(patterns: string[]): PathMatcher;
+/** Whether `path` matches any of the gitignore-style `patterns`. */
+export declare function matchesPathPatterns(path: string, patterns: string[]): boolean;

package/dist/types/src/prompts.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Prompt construction for the two-stage pipeline.
+ *
+ * Stage 1 (summary model): read a diff chunk and describe the change factually.
+ * Stage 2 (final model): turn the summaries into a commit message that obeys the
+ * configured formatting rules (conventional commits, gitmoji, template, body).
+ */
+import type { ChangePriority, Config, DiffSummary } from "./types.ts";
+/** Sentinel separating candidate messages in interactive mode. */
+export declare const OPTION_DELIMITER = "===OPTION===";
+/**
+ * System prompt for the diff-summarization stage. The low-priority variant
+ * asks for a deliberately short summary: the final model only needs to know
+ * which areas changed and how, so the churn cannot crowd out the primary
+ * changes when the summaries are combined.
+ */
+export declare function buildSummarySystem(priority?: ChangePriority): string;
+/** User prompt for a single diff chunk in the summarization stage. */
+export declare function buildSummaryUser(chunk: string, index: number, total: number, priority?: ChangePriority): string;
+/**
+ * JSON schema for the final stage's structured output: a list of candidate
+ * commit messages. Requesting this makes parsing robust regardless of how the
+ * model chooses to format its prose.
+ */
+export declare const MESSAGES_SCHEMA: Record<string, unknown>;
+/** Pull the message list out of a structured-output object, or return null if malformed. */
+export declare function extractMessages(structured: unknown): string[] | null;
+/**
+ * System prompt for the final commit-message stage, encoding all formatting
+ * rules. When `structured` is true, the model returns its messages as JSON, so
+ * the "no markdown" guidance is scoped to each message's own text. When
+ * `hasLowPriority` is true the summaries come in two priority groups and the
+ * weighting rules ({@link lowPriorityWeightingRules}) are added between the
+ * subject-line rules and the body rule, in the order the constraints apply.
+ */
+export declare function buildFinalSystem(config: Config, structured?: boolean, hasLowPriority?: boolean): string;
+/** Whether the summaries span both priority groups (the only case that needs the weighting rules). */
+export declare function hasLowPrioritySummaries(summaries: DiffSummary[]): boolean;
+/**
+ * User prompt for the final stage.
+ *
+ * Summaries are presented by priority group (see {@link describeSummaries}).
+ * In `structured` mode the candidates are returned via {@link MESSAGES_SCHEMA}'s
+ * `messages` array. Otherwise, when `count` > 1, they are separated by
+ * {@link OPTION_DELIMITER} for text parsing.
+ */
+export declare function buildFinalUser(summaries: DiffSummary[], count?: number, structured?: boolean): string;
+/**
+ * Final-stage input for filenamesOnly. JSON-quoted paths keep embedded
+ * newlines and quotes inside a single list item. No diff content is included.
+ */
+export declare function buildFilenamesUser(filenames: {
+    primary: string[];
+    lowPriority: string[];
+}, count?: number, structured?: boolean): string;
+/** Parse the multi-option response from the final stage into individual messages. */
+export declare function parseOptions(text: string): string[];
+/** Strip stray formatting a model may add despite instructions (fences, wrapping quotes). */
+export declare function cleanMessage(text: string): string;