@synmux/claude-commit 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -0,0 +1,204 @@
+# Changelog
+
+All notable changes to `claude-commit` are recorded here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+Each version also has a [GitHub release](https://github.com/synmux/claude-commit/releases)
+carrying the same notes at greater length.
+
+## [1.0.4] - 2026-09-11
+
+### [1.0.4] - Added
+
+- **Filenames-only mode.** Set `"filenamesOnly": true` in your config, or
+  pass `-f` / `--filenames-only`, to skip the summariser and send only
+  filenames to the final model. This reduces model work at the cost of
+  broader, less useful messages; the default remains `false`.
+- Filename lists retain `ignore` filtering and `lowPriorityPaths` weighting,
+  including both paths of renames and copies. Formatting, templates, custom
+  instructions and interactive options still apply; the model is instructed
+  to avoid inventing specific edits or motivations from filenames alone.
+- Verbose output identifies when the summariser was skipped. In this mode,
+  library results contain an empty `summaries` array and `chunkCount: 0`,
+  and the summary model is never called or preloaded.
+
+## [1.0.3] - 2026-09-11
+
+### Added
+
+- **Ollama models.** Any model can run on a local or self-hosted
+  [Ollama](https://ollama.com) server by prefixing its name with `ollama:`;
+  everything after the prefix is the Ollama model name verbatim, tag
+  included. The two pipeline stages resolve independently, so the diff can be
+  summarised locally and free while the final message still goes to Claude.
+  `cco` uses the native `/api/chat` endpoint rather than either compatibility
+  layer, because only the native API can set a context length.
+- **`ollama.context`**, defaulting to `"auto"`. Ollama truncates an oversized
+  prompt silently - HTTP 200, oldest content dropped, nothing in the response
+  to say so - so `cco` never lets the window stay implicit: it preloads the
+  model with no window set, reads the server's own VRAM-based choice back from
+  `/api/ps`, pins that number on every request, sizes chunks against it, and
+  checks the returned token counts to catch a truncation that happened anyway.
+  A number pins the window instead.
+- **`ollama.host`** (defaults to `$OLLAMA_HOST`, then `http://localhost:11434`)
+  and **`ollama.keepAlive`**, plus the `--ollama-host` and `--ollama-context`
+  flags.
+- **`lowPriorityPaths`.** Gitignore-style patterns for churn-heavy paths whose
+  changes are summarised separately, so they cannot crowd out the code in the
+  final message. The content is still read and still costs the same; only its
+  weight changes. `--no-low-priority-paths` disables it for one run.
+- **`ignore`.** The same pattern syntax, but matching file sections are removed
+  from the diff before anything else looks at it - before the low-priority
+  partition, before chunking, before any model call. The files are still
+  committed; `ignore` governs what the model reads, never what git stages. When
+  a pattern matches everything, `cco` stops with an error naming the directive
+  rather than inventing a message about changes you told it not to read.
+  `--no-ignore` disables it for one run.
+
+### Changed
+
+- The default spinner is now `material`.
+- `@opentui/core` bumped to 0.5.7, alongside SDK and skill dependency bumps.
+- CI workflows bump `checkout`, `setup-node` and `claude-code-action`.
+
+## [1.0.2] - 2026-07-27
+
+### [1.0.2] - Changed
+
+- The default spinner is now `dwarfFortress` instead of `bouncingBall`.
+
+## [1.0.1] - 2026-07-27
+
+### [1.0.1] - Added
+
+- **A configurable spinner.** The `spinner` config key accepts any name from
+  the [cli-spinners](https://github.com/sindresorhus/cli-spinners) set bundled
+  with [ora](https://github.com/sindresorhus/ora). Unknown names fall back to
+  the default rather than throwing, because a cosmetic option must never be
+  able to break a commit.
+
+### [1.0.1] - Changed
+
+- The progress spinner is an ora instance rather than a hand-rolled frame
+  timer. Enablement is still decided solely by the existing TTY and
+  `--no-spinner` checks - ora's own CI auto-detection is bypassed - and a final
+  success or failure line still prints when the animation is disabled.
+
+## [1.0.0] - 2026-07-24
+
+### [1.0.0] - Added
+
+- **`--skip-armored`** and the matching `skipArmored` config key, replacing
+  each run of armoured or encoded lines with a short marker. Runs of one or two
+  lines survive, because a lone URL or hash is content. Ciphertext is
+  unreadable to the model and re-encrypts nondeterministically on every
+  `chezmoi re-add`, so this is the recommended mode for repos holding encrypted
+  files.
+
+### [1.0.0] - Fixed
+
+- **Chunks are sized by real token density.** `Prompt is too long` returned,
+  and the isolation fix in 0.1.3 turned out to have treated a symptom. Armoured
+  and base64 content tokenises at roughly 1.14 chars per token on current
+  Claude models, while chunk budgets assumed the configured `charsPerToken` of
+  3.5: a 1,247,318-character diff was estimated at ~356k tokens and really
+  counted ~1.19M. Long unbroken runs are now priced at their own, much denser
+  ratio. A third-party "real tokeniser" would not fix this class of bug -
+  tiktoken-style vocabularies compress base64 about three times better than
+  Claude's actual tokeniser, so they underestimate the same way.
+- **The summary stage is a work queue.** If the backend rejects a chunk anyway
+  (its rejection is free, unbilled, and the only authoritative count), the
+  budget is halved, that chunk is re-split, and processing continues in place.
+
+### [1.0.0] - Changed
+
+- The 0.1.3 documentation blaming these failures on MCP/skill leakage is
+  corrected. That isolation stays as hygiene and cost control, but density was
+  the bug.
+
+## [0.1.4] - 2026-07-23
+
+### [0.1.4] - Fixed
+
+- `cco --version` reported a hardcoded string rather than the installed package
+  version.
+
+## [0.1.3] - 2026-07-23
+
+### [0.1.3] - Fixed
+
+- **Requests no longer inherit your global Claude Code context.** Runs failed
+  reporting ~1,149k tokens against a conversation of only ~301k; the missing
+  ~848k were MCP tool definitions and skills pulled from the user's global
+  configuration into what should be an isolated prompt-in, text-out request.
+  The Agent SDK gates each context source separately, and `settingSources: []`
+  disables only settings files and `CLAUDE.md` - MCP servers and plugins load
+  regardless, and the CLI performs skill discovery even when the `skills`
+  option is omitted. Every switch is now set explicitly in one tested
+  `buildQueryOptions()`.
+- **The chunk budget is clamped to the summary model's context window.**
+  `maxChunkTokens` was converted straight into a character budget regardless of
+  the configured model, so on any 200k-context model a single chunk could
+  exceed the whole window. It is now a cap rather than a promise, clamped to
+  the model's window minus a 32k reserve.
+
+### [0.1.3] - Added
+
+- npm publishing on version tags via CI.
+
+## [0.1.2] - 2026-07-09
+
+### [0.1.2] - Changed
+
+- **Both pipeline stages default to `sonnet`.** The final stage's input is a
+  handful of summaries and its output is the entire point of the tool, so a
+  strong model there costs almost nothing and writes a visibly better message.
+
+### [0.1.2] - Added
+
+- MIT licence.
+
+## [0.1.1] - 2026-07-02
+
+### [0.1.1] - Changed
+
+- Minor tweaks.
+
+## [0.1.0] - 2026-07-02
+
+The first release, published as `@synmux/claude-commit` and providing the `cco`
+and `claude-commit` binaries.
+
+### [0.1.0] - Added
+
+- **The two-stage pipeline.** The diff is split into chunks that fit the
+  context window, each chunk is summarised, and the summaries are handed back
+  to a model to write the final message. Diffs too large for a single context
+  window simply produce more chunks.
+- **Message formatting.** Conventional Commits (`-c`), gitmoji (`-g`),
+  multi-line subject and body (`-m`), a first-line template (`-t`), and
+  free-form extra instructions (`-p`).
+- **Interactive mode.** `cco -i` lists candidate messages in a TUI, generated
+  at a higher temperature for variety, with the scrollable diff alongside.
+- **Layered configuration.** Built-in defaults, a global user config, a
+  `claude-commit` key in the repo's `package.json`, the nearest dotted config
+  file, then CLI flags.
+- **Structured output.** The final message is requested as JSON against a
+  `{ messages: string[] }` schema rather than parsed out of free-form text,
+  degrading to a temperature-free request and then to delimiter parsing.
+- **`allowApiKey`, defaulting to false.** An exported `ANTHROPIC_API_KEY` would
+  otherwise silently switch every generation from subscription auth to
+  pay-as-you-go billing, because the SDK subprocess inherits `process.env`.
+  Those credentials are stripped unless you opt in.
+
+[1.0.4]: https://github.com/synmux/claude-commit/compare/1.0.3...1.0.4
+[1.0.3]: https://github.com/synmux/claude-commit/compare/1.0.2...1.0.3
+[1.0.2]: https://github.com/synmux/claude-commit/compare/1.0.1...1.0.2
+[1.0.1]: https://github.com/synmux/claude-commit/compare/1.0.0...1.0.1
+[1.0.0]: https://github.com/synmux/claude-commit/compare/0.1.4...1.0.0
+[0.1.4]: https://github.com/synmux/claude-commit/compare/0.1.3...0.1.4
+[0.1.3]: https://github.com/synmux/claude-commit/compare/0.1.2...0.1.3
+[0.1.2]: https://github.com/synmux/claude-commit/compare/0.1.1...0.1.2
+[0.1.1]: https://github.com/synmux/claude-commit/compare/0.1.0...0.1.1
+[0.1.0]: https://github.com/synmux/claude-commit/releases/tag/0.1.0

package/README.md

@@ -20,18 +20,27 @@ feat(auth): add error handling and refresh token rotation to login
 Want more details? See [WALKTHROUGH.md](WALKTHROUGH.md).
 
 ```plaintext
-staged diff ──split──▶ [chunk, …] ──sonnet──▶ summaries ──sonnet──▶ commit message
+staged diff ──ignore──▶ ──split──▶ [chunk, …] ──sonnet──▶ summaries ──sonnet──▶ commit message
 ```
 
 1. **Summarize** - the diff is split into chunks that fit the context window and
    each chunk is summarized by a strong model (`sonnet`, which carries a native
    1M-token context). Diffs larger than 1M tokens simply produce more chunks.
+   Paths listed in [`ignore`](#ignoring-paths-entirely) are dropped first and
+   never read at all; changes under configured
+   [low-priority paths](#low-priority-paths) are summarized separately, so churn
+   cannot crowd out the code.
 2. **Write** - the summaries are handed to the same model (`sonnet`) to write the
    final commit message according to your formatting rules. The message is the
    whole point of the tool, and its input is tiny, so a strong model here costs
    almost nothing extra.
 
-Both stages run through the [Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk/overview).
+Either stage can run on a local [Ollama](#ollama-models) model instead; by
+default both go through the
+[Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk/overview).
+
+For less model work at the cost of less useful messages, enable
+[`filenamesOnly`](#filenames-only-mode) to skip summarisation entirely.
 
 ## Install
 
@@ -64,6 +73,9 @@ instead (pay-as-you-go), opt in explicitly in your configuration:
 { "allowApiKey": true }
 ```
 
+Ollama models sit outside all of this: they run on a server you control, over
+plain HTTP, with no credential at all. See [Ollama models](#ollama-models).
+
 ## Usage
 
 ```sh
@@ -86,8 +98,14 @@ and asks for confirmation before committing. Pass `-y` to skip the prompt, or
 | `-m, --multiline` / `--no-multiline`     | Write a multi-line commit (subject + body), or force a single line                      |
 | `-t, --template <tpl>`                   | Template for the first line, e.g. `"[PROJ-1] {message}"`                                |
 | `-p, --prompt <text>`                    | Extra instructions appended to the prompt                                               |
+| `-f, --filenames-only`                   | Skip summarisation and send only filenames to the final model                           |
 | `--model-summary <model>`                | Model used to summarize the diff (default `sonnet`)                                     |
 | `--model-final <model>`                  | Model used to write the message (default `sonnet`)                                      |
+| `--skip-armored`                         | Omit armored/encoded lines (age/gpg armor, base64 blobs) from the summarized diff       |
+| `--no-low-priority-paths`                | Ignore `lowPriorityPaths` for this run, so every change weighs the same                 |
+| `--no-ignore`                            | Disregard `ignore` for this run, so every staged change is read                         |
+| `--ollama-host <url>`                    | Base URL of the Ollama server for `ollama:` models                                      |
+| `--ollama-context <tokens>`              | Context window requested from Ollama models                                             |
 | `-d, --dry-run`                          | Print the message to stdout without committing                                          |
 | `-y, --yes`                              | Commit without asking for confirmation                                                  |
 | `--no-spinner`                           | Disable the progress spinner                                                            |
@@ -101,6 +119,7 @@ cco                      # generate, confirm, and commit staged changes
 cco -a -c                # stage everything and write a Conventional Commit
 cco -c -g -m             # conventional + gitmoji + a body
 cco -i -n 5              # pick from 5 options interactively
+cco -f --dry-run         # generate from filenames only, without committing
 cco --dry-run | cat      # print a message without committing (TUI-free, pipe-safe)
 git commit -F <(cco -d)  # use the message with your own git invocation
 ```
@@ -108,6 +127,31 @@ git commit -F <(cco -d)  # use the message with your own git invocation
 In a pipe (no TTY) there is no spinner and no confirmation prompt - `cco` just
 generates and commits (or prints, with `--dry-run`).
 
+## Filenames-only mode
+
+Set `"filenamesOnly": true` in any config layer, or pass `-f` /
+`--filenames-only`, to send only the list of filenames touched by staged
+changes to `models.final`. The default is `false`.
+
+```json
+{ "filenamesOnly": true }
+```
+
+The summariser is skipped entirely: no diff chunks, summary calls, or
+summary-model preload. The final model receives no file contents or diff
+hunks, so expect broader, less useful messages. It is instructed to describe
+the affected areas without inventing specific edits or reasons for them.
+Normal formatting, custom instructions and interactive options still apply.
+
+`ignore` still removes matching file sections, and `lowPriorityPaths` still
+groups and weights the remaining filenames. Renames and copies include both
+paths; additions, deletions, binary files and mode changes are included.
+If every staged file is ignored, generation still stops with an error.
+
+`models.summary`, `maxChunkTokens`, `charsPerToken` and `skipArmored` have no
+effect in this mode. `--verbose` reports that the summariser was skipped;
+library results have an empty `summaries` array and `chunkCount: 0`.
+
 ## Interactive mode
 
 `cco -i` opens a TUI listing several candidate messages to choose from. The
@@ -151,14 +195,22 @@ keys are valid at every level:
   "interactive": true,
   "interactiveCount": 3,
   "interactiveTemperature": 1,
-  "spinner": "dwarfFortress",
+  "spinner": "material",
   "models": {
     "summary": "sonnet",
     "final": "sonnet"
   },
   "maxChunkTokens": 600000,
   "charsPerToken": 3.5,
+  "filenamesOnly": false,
   "skipArmored": false,
+  "lowPriorityPaths": [],
+  "ignore": [],
+  "ollama": {
+    "host": "http://localhost:11434",
+    "context": "auto",
+    "keepAlive": null
+  },
   "allowApiKey": false
 }
 ```
@@ -166,11 +218,11 @@ keys are valid at every level:
 `spinner` chooses the progress animation: any name from the
 [cli-spinners](https://github.com/sindresorhus/cli-spinners) set bundled with
 [ora](https://github.com/sindresorhus/ora) (`"dots"`, `"moon"`, `"pong"`,
-`"dwarfFortress"`, ...). Unknown names are ignored and the default
-`dwarfFortress` is used. `--no-spinner` disables the animated spinner, but final
+`"material"`, ...). Unknown names are ignored and the default
+`material` is used. `--no-spinner` disables the animated spinner, but final
 status lines still print.
 
-The `dwarfFortress` spinner is chosen because it's fucking cool. Fight me.
+The `material` spinner is chosen because it's fucking cool. Fight me.
 
 `maxChunkTokens` is a cap, not a promise: at run time it is clamped to the
 summary model's context window minus a fixed reserve (1M-window models such as
@@ -195,6 +247,186 @@ every `chezmoi re-add` re-encrypts nondeterministically and produces megabytes
 of churned armor. Drop a `.claude-commit.json` with `{ "skipArmored": true }`
 in the repo root to enable it per-repo.
 
+### Low-priority paths
+
+Some paths change a lot without meaning much - generated docs, lockfiles,
+vendored snapshots, build output. Left alone, a commit that touches twenty
+lines of code and regenerates two thousand lines of tooling gets a subject
+line about the tooling. `lowPriorityPaths` lists gitignore-style patterns for
+those paths:
+
+```json
+{
+  "lowPriorityPaths": [".agents/skills/*-skilld", "bun.lock", "!bun.lock.keep"]
+}
+```
+
+Changes under matching paths are summarised separately and briefly, and the
+model is told that the subject line - and the commit type, scope and gitmoji
+where you use them - comes from the _other_ changes, however small they are.
+The low-priority changes are mentioned in the subject only if they fit, and in
+the body (with `multiline`) only after the primary changes. When _every_
+changed file is low priority there is nothing for it to yield to, so the
+changes are described normally, exactly as if no patterns were configured.
+
+Pattern rules follow `.gitignore` conventions, so trunk or gitignore lines can
+usually be copied in:
+
+- A pattern with a `/` in it is anchored at the repository root and matches a
+  path or any directory above it - `.agents/skills/*-skilld` covers every file
+  inside each matching directory.
+- A pattern without a `/` matches any path segment at any depth - `bun.lock`
+  matches `packages/app/bun.lock`; `*-skilld` matches everything inside any
+  `*-skilld` directory.
+- `*` matches dotfiles and does not cross `/`; `**` does; `{a,b}` expands. A
+  leading `/` or `./` anchors, a trailing `/` is ignored. The anchoring
+  decision looks at the whole pattern, so a `/` inside a brace group anchors
+  all of its alternatives - prefer one pattern per intent.
+- A leading `!` negates, and the last matching pattern wins:
+  `["docs/**", "!docs/adr/**"]` deprioritises docs except the ADRs.
+- Patterns are always matched against repository-root-relative paths with
+  `/` separators, whichever directory you run `cco` from. A backslash in a
+  pattern is an escape (`\[`, `\{`, `\!` for the literal characters), so
+  Windows-style `dist\**` matches nothing.
+- Patterns are not validated: a typo such as an unbalanced `{` is parsed
+  rather than rejected and may match something unexpected, so check the
+  `--verbose` match counts when you add one.
+
+A rename into or out of a low-priority path counts as primary (both sides
+must match). The nearest config layer that sets the key wins outright - lists
+are never merged - so `"lowPriorityPaths": []` in a project opts out of a
+global list, and a project that wants the global patterns plus its own must
+repeat them. `--no-low-priority-paths` switches the feature off for one run,
+which is handy when the churn _is_ the story, or for comparing messages while
+tuning patterns.
+
+This changes how changes are _weighted_ in the message, not how much of the
+diff is read: low-priority content is still summarised in full, at the same
+cost. To skip content outright, see `skipArmored`. Under `--verbose`, `cco`
+reports how many files matched (`low-priority paths: matched 3 of 41 files`),
+which is the only way to tell a pattern that matched nothing from one that
+matched everything and was promoted.
+
+### Ignoring paths entirely
+
+`lowPriorityPaths` still reads everything it deprioritises, and pays for it.
+Some content is worth neither the tokens nor the time: a vendored dependency
+tree, a generated API client, a data fixture that changes wholesale.
+
+`ignore` takes the same gitignore-style patterns and removes those file
+sections from the diff **before anything else looks at it** - before the
+low-priority partition, before chunking, before any model call:
+
+```json
+{ "ignore": ["vendor/**", "**/__snapshots__", "*.generated.ts"] }
+```
+
+The stages compose in the order their names suggest:
+
+```text
+diff ─ ignore ─▶ ─ skipArmored ─▶ ─ lowPriorityPaths ─▶ chunks ─▶ summaries
+```
+
+Two things worth being clear about:
+
+- **The files are still committed.** `ignore` governs what the model reads,
+  never what git stages. `cco` is writing a message, not choosing a changeset.
+- **When it matches _everything_, `cco` stops** with an error naming the
+  directive, rather than inventing a message about changes you told it not to
+  read. This is deliberately unlike `lowPriorityPaths`, which promotes its
+  partition in the same situation - "this matters less" can degrade
+  gracefully, "do not look at this" has nothing to degrade to. Pass
+  `--no-ignore` for that one commit.
+
+As with `lowPriorityPaths`, a section is dropped only when it names at least
+one path and _all_ of them match, so a rename out of an ignored directory
+survives. `--verbose` reports the count
+(`ignore: dropped 3 of 41 files before reading`).
+
+## Ollama models
+
+Any model can be run on a local (or self-hosted) [Ollama](https://ollama.com)
+server instead of Claude, by prefixing its name with `ollama:`. Everything
+after the prefix is the Ollama model name **verbatim**, tag included:
+
+```json
+{
+  "models": {
+    "summary": "ollama:ornith-1.5:35b",
+    "final": "sonnet"
+  }
+}
+```
+
+The two stages resolve independently, so that mixed setup is the interesting
+one: reading the diff is the bulk of the work and the most sensitive thing
+`cco` touches, so it runs locally and free, while the final message - one
+short, quality-sensitive call on a summary - still goes to Claude. The prefix
+works anywhere a model name does, including the flags:
+
+```sh
+cco --model-summary ollama:ornith-1.5:35b --dry-run -v
+```
+
+The server needs no credential. `cco` talks to Ollama's native `/api/chat`
+endpoint, not either of its OpenAI/Anthropic compatibility layers, because
+only the native API can set a context length.
+
+### Context length is the setting that matters
+
+Ollama picks a context window for each model from available VRAM (4k / 32k /
+256k tiers, capped at the model's trained maximum), and a prompt that
+exceeds it is truncated **silently** - HTTP 200, oldest content dropped,
+nothing on the response to say so. A summary written from half a diff is
+worse than no summary, so `cco` never lets that number stay implicit: it
+sends an explicit window on every request, sizes its diff chunks against the
+same number, and checks the token counts afterwards to catch a truncation
+that happened anyway (in which case it re-splits the chunk and retries,
+exactly as it does for a Claude context overflow).
+
+Where the number comes from is `ollama.context`:
+
+```json
+{
+  "ollama": {
+    "host": "http://localhost:11434",
+    "context": "auto",
+    "keepAlive": "10m"
+  }
+}
+```
+
+- `context` - `"auto"` (the default) **asks the server** rather than
+  guessing: the model is preloaded with no window set, so Ollama applies
+  its own VRAM-based choice, and `cco` reads that choice back from
+  `/api/ps` before sizing anything. That is the largest window Ollama
+  believes this machine can actually run - 131072 for a Gemma model on a
+  large Mac, 4096 for the same model on a small laptop - resolved once per
+  model per run, and shown under `--verbose`. A number pins the window
+  instead: lower it when memory is tight (usage scales with it, multiplied
+  by `OLLAMA_NUM_PARALLEL`), or raise it past the tier if you know your
+  hardware better than the server does. A smaller window is never a
+  correctness problem - `cco` just splits the diff into more chunks.
+- `host` - defaults to `$OLLAMA_HOST`, then `http://localhost:11434`. A bare
+  `box.local:11434` gains an `http://`, matching Ollama's own convention.
+- `keepAlive` - how long the server keeps the model loaded after a request: a
+  duration string (`"10m"`), seconds as a number, `0` to unload immediately,
+  or negative to pin it. `null` leaves the server's own default. Pinning is
+  worth it if you commit often; a 35b model takes a while to load.
+
+### What differs from a Claude model
+
+- **Cost is reported as zero**, because local inference is not billed. In a
+  mixed run, `--verbose`'s total is exactly the Claude half.
+- **Structured output** is requested through Ollama's `format` field. A model
+  or server that cannot honour it (Ollama Cloud does not support it at all)
+  falls back to plain-text parsing automatically.
+- **A missing model is an error, not a download.** `cco` tells you to run
+  `ollama pull <model>` rather than pulling tens of gigabytes on your behalf.
+- **Reasoning is never requested**, and any the model volunteers is
+  discarded - models disagree about whether thinking can even be switched
+  off, and asking is a good way to earn a 400.
+
 ## Development
 
 ```sh
@@ -202,6 +434,10 @@ bun test          # run the test suite
 bun run typecheck # tsc --noEmit
 ```
 
+What changed between versions is in [CHANGELOG.md](CHANGELOG.md), and at
+greater length on the
+[releases page](https://github.com/synmux/claude-commit/releases).
+
 ## Did you vibe this?
 
 I distinguish vibe coding and AI-assisted development by

package/index.ts

@@ -9,10 +9,37 @@ export type {
   GenerateOptions,
   GenerateProgress,
   GenerateResult,
+  IgnoreStats,
+  LowPriorityStats,
+  OllamaContextWindow,
 } from "./src/generate";
-export { runPrompt } from "./src/agent";
+export { runClaudePrompt, runPrompt } from "./src/agent";
 export type { RunPromptOptions } from "./src/agent";
-export { splitDiff } from "./src/diff";
+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,
@@ -26,14 +53,18 @@ export {
   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,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synmux/claude-commit",
-  "version": "1.0.2",
-  "description": "Generate git commit messages with Claude, using your Claude Code subscription.",
+  "version": "1.0.4",
+  "description": "Generate git commit messages with Claude, using your Claude Code subscription and/or Ollama.",
   "main": "index.ts",
   "module": "index.ts",
   "type": "module",
@@ -13,39 +13,53 @@
   "files": [
     "bin",
     "src",
-    "index.ts"
+    "index.ts",
+    "CHANGELOG.md"
   ],
   "claude-commit": {
+    "allowApiKey": false,
+    "charsPerToken": 3.5,
     "conventionalCommits": true,
-    "gitmoji": true,
-    "multiline": true,
-    "template": null,
     "customPrompt": null,
+    "filenamesOnly": false,
+    "gitmoji": true,
     "interactive": false,
-    "interactiveCount": 3,
+    "interactiveCount": 10,
     "interactiveTemperature": 1,
-    "spinner": "dwarfFortress",
+    "lowPriorityPaths": [
+      ".agents/**",
+      ".claude/**",
+      "bun.lock",
+      ".serena"
+    ],
+    "maxChunkTokens": 32768,
     "models": {
-      "summary": "sonnet",
-      "final": "sonnet"
+      "summary": "ollama:gemma4:e4b-mlx",
+      "final": "ollama:gemma4:e4b-mlx"
     },
-    "maxChunkTokens": 600000,
-    "charsPerToken": 3.5,
-    "allowApiKey": false
+    "multiline": true,
+    "ollama": {
+      "host": "http://localhost:11434",
+      "context": "auto",
+      "keepAlive": "10m"
+    },
+    "skipArmored": true,
+    "spinner": "pong",
+    "template": null
   },
   "devDependencies": {
-    "@anthropic-ai/claude-code": "^2.1.218",
+    "@anthropic-ai/claude-code": "^2.1.241",
     "@trunkio/launcher": "^1.3.4",
-    "@types/bun": "^1.3.14",
+    "@types/bun": "^1.4.0",
     "prettier": "3.9.4",
-    "skilld": "^2.0.0"
+    "skilld": "^2.3.0"
   },
   "peerDependencies": {
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.218",
-    "@opentui/core": "^0.4.5",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.241",
+    "@opentui/core": "^0.5.7",
     "cli-spinners": "^3.4.0",
     "commander": "^15.0.0",
     "ora": "^9.4.1"