@synmux/claude-commit 1.0.4 → 1.1.0

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

@@ -0,0 +1,58 @@
+/** Estimate the number of tokens in `text` given a chars-per-token ratio. */
+export declare function estimateTokens(text: string, charsPerToken: number): number;
+/** Convert a token budget into an approximate character budget. */
+export declare function tokensToChars(tokens: number, charsPerToken: number): number;
+/**
+ * The context window (input token capacity) for a model name or alias.
+ *
+ * For an `ollama:` model the window is not a property of the name at all -
+ * it is whatever `options.num_ctx` the request asks for, which cco pins to
+ * `ollama.contextTokens` so that chunk sizing and the request agree. Pass
+ * that value as `ollamaContextTokens`; the default matches
+ * {@link DEFAULT_OLLAMA_CONTEXT_TOKENS}.
+ */
+export declare function contextWindowTokens(model: string, ollamaContextTokens?: number): number;
+/**
+ * Ceiling on the tokens reserved out of the context window before sizing
+ * diff chunks: the system prompt, the backend's scaffolding, and room for
+ * the response. Generous on purpose - `charsPerToken` is an estimate, and a
+ * chunk that overflows the window fails the whole run.
+ */
+export declare const CONTEXT_RESERVE_TOKENS = 32000;
+/**
+ * Tokens to hold back from `contextWindow` when sizing chunks: the flat
+ * reserve, or a quarter of the window when that is smaller. Both Claude
+ * tiers (200k and 1M) are far above the crossover, so they reserve the full
+ * 32k exactly as before; only windows under 128k - which in practice means
+ * Ollama - scale down.
+ */
+export declare function contextReserveTokens(contextWindow: number): number;
+/**
+ * Clamp a configured per-chunk token budget so that one chunk plus overhead
+ * always fits the given model's context window. The configured
+ * `maxChunkTokens` remains the user-facing cap; this only ever lowers it.
+ * `ollamaContextTokens` supplies the window for an `ollama:` model.
+ */
+export declare function clampChunkTokens(model: string, maxChunkTokens: number, ollamaContextTokens?: number): number;
+/**
+ * Chars-per-token for "opaque" content: base64/base85 armor (age, gpg, git
+ * binary patches), long hashes, and similar high-entropy runs. Measured
+ * against the live API on age-armor diff content (2026-07-23): ~1.14
+ * chars/token - the current Claude tokenizer finds almost no merges in
+ * random base64. Note that generic BPE vocabularies (tiktoken-class)
+ * compress base64 roughly 3x better, so swapping in a third-party "real"
+ * tokenizer would underestimate this content class just like a plain
+ * chars/3.5 heuristic does. 1.0 leaves a small safety margin under the
+ * measured value.
+ */
+export declare const OPAQUE_CHARS_PER_TOKEN = 1;
+/** Whether a single diff line should be estimated at the opaque ratio. */
+export declare function isOpaqueLine(line: string): boolean;
+/**
+ * Estimate tokens for diff text with per-line content classification:
+ * opaque lines at {@link OPAQUE_CHARS_PER_TOKEN}, everything else at the
+ * configured `charsPerToken`. A single blended ratio underestimates
+ * armor-heavy diffs more than threefold, which is exactly how a chunk that
+ * looks within budget can overflow the model's real context window.
+ */
+export declare function estimateDiffTokens(text: string, charsPerToken: number): number;

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

@@ -0,0 +1,234 @@
+/**
+ * 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;
+    /**
+     * Skip diff summarisation and send only changed filenames to the final
+     * model. Uses less time and tokens at the cost of less useful messages.
+     * Defaults to false; ignore and lowPriorityPaths still apply.
+     */
+    filenamesOnly: boolean;
+    /**
+     * 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/colors.ts → dist/types/src/ui/colors.d.ts}

@@ -4,9 +4,6 @@
  * Color is emitted only when stderr is a TTY and `NO_COLOR` is unset, so escape
  * codes never leak into redirected logs or CI output.
  */
-export const useColor = Boolean(process.stderr.isTTY) && !process.env.NO_COLOR;
-
+export declare const useColor: boolean;
 /** Wrap `text` in an ANSI SGR sequence when color is enabled, else return it unchanged. */
-export function color(code: string, text: string): string {
-  return useColor ? `\x1b[${code}m${text}\x1b[0m` : text;
-}
+export declare function color(code: string, text: string): string;

package/dist/types/src/ui/spinner.d.ts

@@ -0,0 +1,23 @@
+import { type Spinner as SpinnerAnimation } from "cli-spinners";
+/** The spinner used when none (or an unknown one) is configured. */
+export declare const DEFAULT_SPINNER = "material";
+/** Whether `name` is one of the cli-spinners animations bundled with ora. */
+export declare function isSpinnerName(name: string): boolean;
+/**
+ * Look up a spinner animation by name, falling back to {@link DEFAULT_SPINNER}
+ * for unknown names (ora itself throws on those, and a cosmetic option must
+ * never be able to break a commit).
+ */
+export declare function resolveSpinner(name: string): SpinnerAnimation;
+export declare class Spinner {
+    private instance;
+    private readonly enabled;
+    private readonly animation;
+    constructor(enabled?: boolean, spinnerName?: string);
+    start(label: string): void;
+    update(label: string): void;
+    /** Stop and clear the spinner line, optionally printing a final status line. */
+    stop(finalLine?: string): void;
+    succeed(label: string): void;
+    fail(label: string): void;
+}

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@synmux/claude-commit",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "Generate git commit messages with Claude, using your Claude Code subscription and/or Ollama.",
-  "main": "index.ts",
-  "module": "index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "type": "module",
   "private": false,
   "bin": {
-    "cco": "bin/cco.ts",
-    "claude-commit": "bin/cco.ts"
+    "cco": "bin/cco.js",
+    "claude-commit": "bin/cco.js"
   },
   "files": [
     "bin",
-    "src",
-    "index.ts",
+    "dist",
     "CHANGELOG.md"
   ],
   "claude-commit": {
@@ -30,12 +36,13 @@
       ".agents/**",
       ".claude/**",
       "bun.lock",
+      "pnpm-lock.yaml",
       ".serena"
     ],
-    "maxChunkTokens": 32768,
+    "maxChunkTokens": 750000,
     "models": {
-      "summary": "ollama:gemma4:e4b-mlx",
-      "final": "ollama:gemma4:e4b-mlx"
+      "summary": "opus",
+      "final": "opus"
     },
     "multiline": true,
     "ollama": {
@@ -48,40 +55,44 @@
     "template": null
   },
   "devDependencies": {
-    "@anthropic-ai/claude-code": "^2.1.241",
+    "@anthropic-ai/claude-code": "^2.1.263",
     "@trunkio/launcher": "^1.3.4",
-    "@types/bun": "^1.4.0",
+    "@types/node": "^24.13.3",
+    "@types/picomatch": "^4.0.3",
+    "esbuild": "^0.27.7",
     "prettier": "3.9.4",
-    "skilld": "^2.3.0"
+    "skilld": "^2.3.0",
+    "vitest": "^4.1.11"
+  },
+  "engines": {
+    "node": "^24.20.0"
   },
   "peerDependencies": {
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.241",
-    "@opentui/core": "^0.5.7",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.263",
+    "@clack/core": "^1.4.3",
+    "@clack/prompts": "^1.7.0",
     "cli-spinners": "^3.4.0",
     "commander": "^15.0.0",
-    "ora": "^9.4.1"
+    "ora": "^9.4.1",
+    "picomatch": "^4.0.7"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/synmux/claude-commit"
+    "url": "git+https://github.com/synmux/claude-commit.git"
   },
   "scripts": {
-    "start": "bun run bin/cco.ts",
-    "test": "bun test",
-    "format": "bun run prettier --write . && bun run trunk fmt -a",
-    "lint": "bun run trunk check -a",
-    "lint:fix": "bun run trunk check -a --fix",
-    "typecheck": "bun run tsc --noEmit",
-    "prepare": "bun run skilld prepare || true"
+    "start": "node bin/cco.js",
+    "build": "esbuild bin/cco.ts index.ts --bundle --platform=node --format=esm --packages=external --outbase=. --outdir=dist && tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "format": "prettier --write . && trunk fmt -a",
+    "lint": "trunk check -a",
+    "lint:fix": "trunk check -a --fix",
+    "lint:types": "tsc --noEmit",
+    "prepare": "skilld prepare || true",
+    "prepublishOnly": "pnpm run build"
   },
-  "trustedDependencies": [
-    "@anthropic-ai/claude-code",
-    "@google/genai",
-    "onnxruntime-node",
-    "protobufjs",
-    "sharp"
-  ]
+  "packageManager": "pnpm@12.4.1+sha512.2e81e399d73fe8390dab25e06aa788ab7a5908248d2f5a370f82b481147a6a7a367bf8048f9a6fdb6460f21a66f0542dedb8b94ca2c8723596741920b1656d4c"
 }

package/index.ts

@@ -1,71 +0,0 @@
-/**
- * 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";
-export type {
-  GenerateOptions,
-  GenerateProgress,
-  GenerateResult,
-  IgnoreStats,
-  LowPriorityStats,
-  OllamaContextWindow,
-} from "./src/generate";
-export { runClaudePrompt, runPrompt } from "./src/agent";
-export type { RunPromptOptions } from "./src/agent";
-export {
-  probeOllamaContext,
-  resolveOllamaContext,
-  resolveOllamaHost,
-  runOllamaPrompt,
-} from "./src/ollama";
-export {
-  DEFAULT_OLLAMA_CONTEXT,
-  DEFAULT_OLLAMA_CONTEXT_TOKENS,
-  DEFAULT_OLLAMA_HOST,
-  isOllamaModel,
-  OLLAMA_PREFIX,
-  parseModelRef,
-} from "./src/models";
-export type { ModelProvider, ModelRef } from "./src/models";
-export {
-  applyIgnorePatterns,
-  diffPaths,
-  partitionDiff,
-  sectionPaths,
-  splitDiff,
-} from "./src/diff";
-export type { DiffPartition, IgnoreResult } from "./src/diff";
-export { createPathMatcher, matchesPathPatterns } from "./src/paths";
-export type { PathMatcher } from "./src/paths";
-export {
-  DEFAULT_CONFIG,
-  loadFileConfig,
-  resolveConfig,
-  mergeConfig,
-  mergePartial,
-  sanitizePartial,
-} from "./src/config";
-export {
-  buildSummarySystem,
-  buildSummaryUser,
-  buildFinalSystem,
-  buildFinalUser,
-  buildFilenamesUser,
-  parseOptions,
-  cleanMessage,
-} from "./src/prompts";
-export * as git from "./src/git";
-export { ClaudeCommitError } from "./src/errors";
-export type {
-  ChangePriority,
-  Config,
-  DiffSummary,
-  ModelConfig,
-  OllamaConfig,
-  PartialConfig,
-  ModelResult,
-  FileChange,
-} from "./src/types";